name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Matrix.IsPrimitive.nonneg | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : Fintype n] [inst_3 : DecidableEq n]
{A : Matrix n n R}, A.IsPrimitive → ∀ (i j : n), 0 ≤ A i j | true |
_private.Mathlib.MeasureTheory.Measure.Dirac.0.MeasureTheory.Measure.dirac_apply_eq_zero_or_one._simp_1_1 | Mathlib.MeasureTheory.Measure.Dirac | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = y) = (p → x = y) | false |
OrderMonoidIso.noConfusionType | Mathlib.Algebra.Order.Hom.Monoid | Sort u →
{α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : Mul α] →
[inst_3 : Mul β] →
(α ≃*o β) →
{α' : Type u_6} →
{β' : Type u_7} →
[inst' : Preorder α'] →
... | false |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj.presheafObjObjIso._proof_2 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u_7} {C : Type u_4} [inst : CategoryTheory.Category.{u_6, u_7} C₀]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] {F : CategoryTheory.Functor C₀ C}
{J₀ : CategoryTheory.GrothendieckTopology C₀} {J : CategoryTheory.GrothendieckTopology C} {A : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} A]... | false |
MeasureTheory.measure_inter_inv_smul | Mathlib.MeasureTheory.Group.Action | ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
(μ : MeasureTheory.Measure α) [MeasureTheory.SMulInvariantMeasure G α μ] (c : G) (s t : Set α),
μ (s ∩ c⁻¹ • t) = μ (c • s ∩ t) | true |
ContinuousMap.HomotopyWith.apply_one | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
{P : C(X, Y) → Prop} (F : f₀.HomotopyWith f₁ P) (x : X), F (1, x) = f₁ x | true |
Mathlib.Tactic.BicategoryLike.MkEqOfNaturality.noConfusionType | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | Sort u →
{m : Type → Type} →
Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m →
{m' : Type → Type} → Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m' → Sort u | false |
CategoryTheory.ThinSkeleton.fromThinSkeleton_map | Mathlib.CategoryTheory.Skeletal | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : Quiver.IsThin C]
{x y : CategoryTheory.ThinSkeleton C} (a : x ⟶ y),
(CategoryTheory.ThinSkeleton.fromThinSkeleton C).map a =
Quotient.recOnSubsingleton₂ (motive := fun x x_1 => (x ⟶ x_1) → (Quotient.out x ⟶ Quotient.out x_1)) x y
(fun X... | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullback_to_base_isOpenImmersion | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Z) (g : Y ⟶ Z)
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
[inst : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion g],
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion
(CategoryTheory.Limits.limit.π (CategoryTheory.Limits.cosp... | true |
CategoryTheory.Functor.closedUnit._proof_3 | Mathlib.CategoryTheory.Monoidal.Closed.FunctorCategory.Groupoid | ∀ {D : Type u_3} {C : Type u_4} [inst : CategoryTheory.Groupoid D] [inst_1 : CategoryTheory.Category.{u_2, u_4} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
(F : CategoryTheory.Functor D C) ⦃X Y : CategoryTheory.Functor D C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.... | false |
CategoryTheory.Monad.left_unit | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Monad C) (X : C),
CategoryTheory.CategoryStruct.comp (self.η.app (self.obj X)) (self.μ.app X) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id C).obj (self.obj X)) | true |
Ideal.relNorm_mono | Mathlib.RingTheory.Ideal.Norm.RelNorm | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] {S : Type u_3} [inst_2 : CommRing S] [inst_3 : IsDomain S]
[inst_4 : IsIntegrallyClosed R] [inst_5 : IsIntegrallyClosed S] [inst_6 : Algebra R S] [inst_7 : Module.Finite R S]
[inst_8 : Module.IsTorsionFree R S] [inst_9 : IsDedekindDomain R] [inst_10 : IsDed... | true |
Nat.lt_iff_le_and_not_ge | Init.Data.Nat.Basic | ∀ {m n : ℕ}, m < n ↔ m ≤ n ∧ ¬n ≤ m | true |
String.Slice.Pattern.SearchStep.rejected.sizeOf_spec | Init.Data.String.Pattern.Basic | ∀ {s : String.Slice} (startPos endPos : s.Pos),
sizeOf (String.Slice.Pattern.SearchStep.rejected startPos endPos) = 1 + sizeOf startPos + sizeOf endPos | true |
Lean.Compiler.LCNF.SpecEntry.noConfusionType | Lean.Compiler.LCNF.SpecInfo | Sort u → Lean.Compiler.LCNF.SpecEntry → Lean.Compiler.LCNF.SpecEntry → Sort u | false |
CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_inv_comp_rightHomologyι_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) [inst_2 : S.HasRightHomology] {Z : C}
(h_1 : S.opcycles ⟶ Z),
CategoryTheory.CategoryStruct.comp h.rightHomologyIso.inv (CategoryTheory.C... | true |
GroupWithZero.noZeroDivisors | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀], NoZeroDivisors G₀ | true |
DerivedCategory.HomologySequence.exact₁ | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] (T : CategoryTheory.Pretriangulated.Triangle (DerivedCategory C))
(hT : T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles) (n₀ n₁ : ℤ)
(h : autoParam (n₀ + 1 = n₁) DerivedCategory.H... | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.filter_key_equiv_self_iff._simp_1_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β},
m₁.Equiv m₂ = (Std.DHashMap.Internal.toListModel m₁.buckets).Perm (Std.DHashMap.Internal.toListModel m₂.buckets) | false |
Option.attachWith_none | Init.Data.Option.Attach | ∀ {α : Type u_1} {P : α → Prop} {H : ∀ (x : α), none = some x → P x}, none.attachWith P H = none | true |
CategoryTheory.ShortComplex.SnakeInput.op | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
CategoryTheory.ShortComplex.SnakeInput C → CategoryTheory.ShortComplex.SnakeInput Cᵒᵖ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey?_insert._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
LinearMap.flip_apply | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] {R₂ : Type u_3} [inst_2 : Semiring R₂]
{S₂ : Type u_4} [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_6} {P : Type u_7} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module... | true |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_2 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : ↥(Unitization.unitsFstOne R A)),
PreQuasiregular.equiv.symm (PreQuasiregular.equiv (↑↑x⁻¹).toProd.2 * PreQuasiregular.equiv (↑↑x).toProd.2) ... | false |
Finsupp.embDomain_add | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {F : Type u_2} {M : Type u_3} [inst : AddZeroClass M] (f : ι ↪ F) (v w : ι →₀ M),
Finsupp.embDomain f (v + w) = Finsupp.embDomain f v + Finsupp.embDomain f w | true |
ZFSet.Definable₁.out_equiv | Mathlib.SetTheory.ZFC.Basic | ∀ (f : ZFSet.{u} → ZFSet.{u}) [inst : ZFSet.Definable₁ f] {x y : PSet.{u}},
x ≈ y → ZFSet.Definable₁.out f x ≈ ZFSet.Definable₁.out f y | true |
AnalyticWithinAt.sub | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F} {s : Set E}
{x : E}, AnalyticWithinAt 𝕜 f s x → AnalyticWithinAt 𝕜 g s x → AnalyticWithinAt 𝕜 (... | true |
TensorProduct.smul_tmul_smul | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (r s : R) (m : M) (n : N),
(r • m) ⊗ₜ[R] (s • n) = (r * s) • m ⊗ₜ[R] n | true |
_private.Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing.0.AlgebraicGeometry.PresheafedSpace.GlueData.ιInvApp_π._simp_1_2 | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary.induct_unfolding | Init.Data.String.Pattern.String | ∀ (pat : String.Slice)
(motive :
((table : Array ℕ) ×'
(_ : 0 < table.size) ×' (_ : table.size ≤ pat.utf8ByteSize) ×' ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) →
Vector ℕ pat.utf8ByteSize → Prop),
(∀ (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i... | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.neg_slt_zero._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a != b) = false) = (a = b) | false |
CategoryTheory.Aut.toEnd._proof_1 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
MonoidHomClass (CategoryTheory.Aut X ≃* (CategoryTheory.End X)ˣ) (CategoryTheory.Aut X) (CategoryTheory.End X)ˣ | false |
UInt32.toUInt16_add | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), (a + b).toUInt16 = a.toUInt16 + b.toUInt16 | true |
_private.Lean.Compiler.LCNF.AuxDeclCache.0.Lean.Compiler.LCNF.instHashableAuxDeclCacheKey.hash.match_1 | Lean.Compiler.LCNF.AuxDeclCache | (motive : Lean.Compiler.LCNF.AuxDeclCacheKey → Sort u_1) →
(x : Lean.Compiler.LCNF.AuxDeclCacheKey) →
((a : Lean.Compiler.LCNF.Purity) → (a_1 : Lean.Compiler.LCNF.Decl a) → motive { pu := a, decl := a_1 }) → motive x | false |
AlgebraicGeometry.IsClosedImmersion.isIso_of_injective_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsAffine Y] {f : X ⟶ Y} [AlgebraicGeometry.IsClosedImmersion f],
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.appTop f)) →
CategoryTheory.IsIso f | true |
_private.Init.Data.List.Impl.0.List.modifyTR_go_eq | Init.Data.List.Impl | ∀ {α : Type u_1} {f : α → α} {acc : Array α} (l : List α) (i : ℕ),
List.modifyTR.go✝ f l i acc = acc.toList ++ l.modify i f | true |
DirectLimit.instSemiringOfRingHomClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → Semiring (G i)]
[∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j),
NonUnitalRingHomClass (T h) (G i) (G j) | false |
Polynomial.reverse_neg | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Ring R] (f : Polynomial R), (-f).reverse = -f.reverse | true |
AlgebraicGeometry.PresheafedSpace.categoryOfPresheafedSpaces._proof_6 | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z : AlgebraicGeometry.PresheafedSpace C}
(f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
AlgebraicGeometry.PresheafedSpace.comp (AlgebraicGeometry.PresheafedSpace.comp f g) h =
AlgebraicGeometry.PresheafedSpace.comp f (AlgebraicGeometry.Presheafed... | false |
CategoryTheory.IsMonoidalRightDistrib.preservesBinaryCoproducts_tensorRight._autoParam | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.Syntax | false |
Lean.addProtected | Lean.Modifiers | Lean.Environment → Lean.Name → Lean.Environment | true |
_private.Lean.Elab.PreDefinition.FixedParams.0.Lean.Elab.FixedParamPerm.pickFixed.go._sunfold | Lean.Elab.PreDefinition.FixedParams | {α : Type u_1} → List (Option ℕ × α) → Array α → Id (Array α) | false |
_private.Lean.Elab.Tactic.SimpTrace.0.Lean.Elab.Tactic.evalSimpTrace.match_1 | Lean.Elab.Tactic.SimpTrace | (motive :
Option
(Lean.Syntax.TSepArray
[`Lean.Parser.Tactic.simpStar, `Lean.Parser.Tactic.simpErase, `Lean.Parser.Tactic.simpLemma] ",") →
Sort u_1) →
(args :
Option
(Lean.Syntax.TSepArray
[`Lean.Parser.Tactic.simpStar, `Lean.Parser.Tactic.simpErase, `Lean.Parser.T... | false |
AlgEquiv.coe_algHom | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), ⇑↑e = ⇑e | true |
Aesop.Substitution | Aesop.Forward.Substitution | Type | true |
CategoryTheory.Limits.hasFiniteCoproducts_of_opposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasFiniteProducts Cᵒᵖ],
CategoryTheory.Limits.HasFiniteCoproducts C | true |
_private.Init.Data.List.Lemmas.0.List.reverseAux.match_1.eq_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (r : List α) (h_1 : (r : List α) → motive [] r)
(h_2 : (a : α) → (l r : List α) → motive (a :: l) r),
(match [], r with
| [], r => h_1 r
| a :: l, r => h_2 a l r) =
h_1 r | true |
CategoryTheory.RetractArrow.leftLiftingProperty | Mathlib.CategoryTheory.LiftingProperties.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y Z W Z' W' : C} {g : Z ⟶ W} {g' : Z' ⟶ W'}
(h : CategoryTheory.RetractArrow g' g) (f : X ⟶ Y) [CategoryTheory.HasLiftingProperty g f],
CategoryTheory.HasLiftingProperty g' f | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Defs.0.hasFDerivAt_iff_isLittleOTVS._simp_1_2 | Mathlib.Analysis.Calculus.FDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (f : E → F) (f' : E →L[𝕜] F) (L : Filter (E × E)),
HasFDerivAtFilter f ... | false |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_12 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (hp₀ : ¬p₀ = s.endPos),
(p₀.get hp₀ = '0' ∧ ∃ (h : p₀.next hp₀ ≠ s.endPos), (p₀.next hp₀).get h = '0') → p₀.next hp₀ ≠ s.endPos | false |
SSet.Subcomplex.Pairing.RankFunction.mk.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {α : Type v} [inst : PartialOrder α] (rank rank_1 : ↑P.II → α)
(e_rank : rank = rank_1) (lt : ∀ {x y : ↑P.II}, P.AncestralRel x y → rank x < rank y),
{ rank := rank, lt := lt } = { rank := rank_1, lt := ⋯ } | true |
MeasureTheory.diff_mem_measurableCylinders | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)] {s t : Set ((i : ι) → α i)},
s ∈ MeasureTheory.measurableCylinders α →
t ∈ MeasureTheory.measurableCylinders α → s \ t ∈ MeasureTheory.measurableCylinders α | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis.0.Tactic.ComputeAsymptotics.BasisExtension.getBasis.match_1.eq_3 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ (motive : (basis : Tactic.ComputeAsymptotics.Basis) → Tactic.ComputeAsymptotics.BasisExtension basis → Sort u_1)
(basis : Tactic.ComputeAsymptotics.Basis) (f : ℝ → ℝ) (ex : Tactic.ComputeAsymptotics.BasisExtension basis)
(h_1 : Unit → motive [] Tactic.ComputeAsymptotics.BasisExtension.nil)
(h_2 :
(basis_hd ... | true |
CategoryTheory.Oplax.LaxTrans.naturality_naturality._autoParam | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | Lean.Syntax | false |
MvPFunctor.const.mk_get | Mathlib.Data.PFunctor.Multivariate.Basic | ∀ {n : ℕ} {A : Type u} {α : TypeVec.{u} n} (x : ↑(MvPFunctor.const n A) α),
MvPFunctor.const.mk n (MvPFunctor.const.get x) = x | true |
Std.DHashMap.Internal.AssocList.getKey.congr_simp | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a a_1 : α) (e_a : a = a_1) (l l_1 : Std.DHashMap.Internal.AssocList α β)
(e_l : l = l_1) (a_2 : Std.DHashMap.Internal.AssocList.contains a l = true),
Std.DHashMap.Internal.AssocList.getKey a l a_2 = Std.DHashMap.Internal.AssocList.getKey a_1 l_1 ⋯ | true |
SimplicialObject.opObjIso.eq_1 | Mathlib.AlgebraicTopology.SimplicialObject.Op | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] {X : CategoryTheory.SimplicialObject C}
{n : SimplexCategoryᵒᵖ},
SimplicialObject.opObjIso = CategoryTheory.Iso.refl ((SimplicialObject.opFunctor.obj X).obj n) | true |
AddAction.IsTopologicallyTransitive.exists_vadd_inter | Mathlib.Dynamics.Transitive | ∀ {M : Type u_1} {α : Type u_2} {inst : AddMonoid M} {inst_1 : TopologicalSpace α} {inst_2 : AddAction M α}
[self : AddAction.IsTopologicallyTransitive M α] {U V : Set α},
IsOpen U → U.Nonempty → IsOpen V → V.Nonempty → ∃ m, ((m +ᵥ U) ∩ V).Nonempty | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_5 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | false |
MagmaCat.instCategory.eq_1 | Mathlib.Algebra.Category.Semigrp.Basic | MagmaCat.instCategory =
{ Hom := fun X Y => X.Hom Y, id := fun X => { hom' := MulHom.id ↑X },
comp := fun {X Y Z} f g => { hom' := g.hom'.comp f.hom' }, id_comp := @MagmaCat.instCategory._proof_1,
comp_id := @MagmaCat.instCategory._proof_2, assoc := @MagmaCat.instCategory._proof_3 } | true |
_private.Mathlib.Topology.Bornology.BoundedOperation.0.instBoundedMulOfLipschitzMul._simp_2 | Mathlib.Topology.Bornology.BoundedOperation | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
Vector.back | Init.Data.Vector.Basic | {n : ℕ} → {α : Type u_1} → [NeZero n] → Vector α n → α | true |
CategoryTheory.Square.arrowArrowEquivalence_unitIso | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.Square.arrowArrowEquivalence.unitIso =
CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C)) | true |
Lean.IR.EmitLLVM.toLLVMType | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → Lean.IR.IRType → Lean.IR.EmitLLVM.M llvmctx (LLVM.LLVMType llvmctx) | true |
Finsupp.preorder | Mathlib.Order.Preorder.Finsupp | {ι : Type u_1} → {M : Type u_2} → [inst : Zero M] → [Preorder M] → Preorder (ι →₀ M) | true |
UpperSet.instMin | Mathlib.Order.UpperLower.CompleteLattice | {α : Type u_1} → [inst : LE α] → Min (UpperSet α) | true |
Polynomial.comp_eq_sum_left | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, p.comp q = p.sum fun e a => Polynomial.C a * q ^ e | true |
isAtomic_of_orderBot_wellFounded_lt | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : OrderBot α], (WellFounded fun x1 x2 => x1 < x2) → IsAtomic α | true |
AlgebraicGeometry.ProjectiveSpectrum.comapFun._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Functor | ∀ {A : Type u_2} {B : Type u_1} {σ : Type u_3} {τ : Type u_4} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : CommRing B] [inst_3 : SetLike τ B] {𝒜 : ℕ → σ} {ℬ : ℕ → τ}, RingHomClass (𝒜 →+*ᵍ ℬ) A B | false |
CategoryTheory.Abelian.freyd_mitchell | Mathlib.CategoryTheory.Abelian.FreydMitchell | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C],
∃ R x F,
F.Full ∧
F.Faithful ∧ CategoryTheory.Limits.PreservesFiniteLimits F ∧ CategoryTheory.Limits.PreservesFiniteColimits F | true |
Std.DTreeMap.isSome_getKey?_eq_contains | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {a : α},
(t.getKey? a).isSome = t.contains a | true |
Lean.Grind.Semiring.noConfusion | Init.Grind.Ring.Basic | {P : Sort u_1} →
{α : Type u} →
{t : Lean.Grind.Semiring α} →
{α' : Type u} → {t' : Lean.Grind.Semiring α'} → α = α' → t ≍ t' → Lean.Grind.Semiring.noConfusionType P t t' | false |
CategoryTheory.Injective.injective_iff_preservesEpimorphisms_preadditive_yoneda_obj' | Mathlib.CategoryTheory.Preadditive.Yoneda.Injective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (J : C),
CategoryTheory.Injective J ↔ (CategoryTheory.preadditiveYonedaObj J).PreservesEpimorphisms | true |
CongruenceSubgroup.Gamma1' | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | (N : ℕ) → Subgroup ↥(CongruenceSubgroup.Gamma0 N) | true |
CategoryTheory.Precoverage.ZeroHypercover.map.congr_simp | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S : C} {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {K : CategoryTheory.Precoverage D} (F : CategoryTheory.Functor C D)
(E E_1 : J.ZeroHypercover S),
E = E_1 →
∀ (h : J ≤ CategoryTheory.Precoverage.c... | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_neg_of_not_negOverflow._proof_1_4 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x : BitVec (w + 1)}, -2 ^ w ≤ x.toInt → ¬x.toInt = -2 ^ w → ¬-x.toInt < (2 ^ (w + 1) + 1) / 2 → False | false |
MeasureTheory.IntegrableOn.continuousOn_smul_of_subset | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {E : Type u_6} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure X} [OpensMeasurableSpace X] {A K : Set X} {𝕜 : Type u_9} [inst_4 : NormedRing 𝕜]
[inst_5 : Module 𝕜 E] [NormSMulClass 𝕜 E] [SecondCountableTopologyEither X 𝕜] {f :... | true |
WittVector.wittMulN | Mathlib.RingTheory.WittVector.MulP | (p : ℕ) → [hp : Fact (Nat.Prime p)] → ℕ → ℕ → MvPolynomial ℕ ℤ | true |
Real.fourierIntegral_continuousLinearMap_apply | Mathlib.Analysis.Fourier.FourierTransform | ∀ {V : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V] [inst_6 : FiniteDimensional ℝ V]
{F : Type u_4} [inst_7 : NormedAddCommGroup F] [inst_8 : NormedSpace ℝ F] {f... | true |
_private.Mathlib.MeasureTheory.Function.AbsolutelyContinuous.0.AbsolutelyContinuousOnInterval.boundedVariationOn._simp_1_5 | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {α : Type u_1} {s : Finset α} {f : α → ENNReal}, (∑ x ∈ s, f x = ⊤) = ∃ a ∈ s, f a = ⊤ | false |
Lean.Meta.DefaultInstances.rec | Lean.Meta.Instances | {motive : Lean.Meta.DefaultInstances → Sort u} →
((defaultInstances : Lean.NameMap (List (Lean.Name × ℕ))) →
(priorities : Lean.Meta.PrioritySet) →
motive { defaultInstances := defaultInstances, priorities := priorities }) →
(t : Lean.Meta.DefaultInstances) → motive t | false |
AlgebraicGeometry.LocallyRingedSpace.toΓSpec | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | (X : AlgebraicGeometry.LocallyRingedSpace) →
X ⟶ AlgebraicGeometry.Spec.locallyRingedSpaceObj (AlgebraicGeometry.LocallyRingedSpace.Γ.obj (Opposite.op X)) | true |
_private.Lean.Meta.Tactic.Grind.Core.0.Lean.Meta.Grind.addEq | Lean.Meta.Tactic.Grind.Core | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit | true |
AddSubmonoid.decidableMemCenter.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : AddMonoid M] (a : M) [inst_1 : Decidable (∀ (b : M), b + a = a + b)],
AddSubmonoid.decidableMemCenter a = decidable_of_iff' (∀ (g : M), g + a = a + g) ⋯ | true |
SSet.Subcomplex.Pairing.rank' | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RankNat | {X : SSet} → {A : X.Subcomplex} → (P : A.Pairing) → {y : ↑P.II} → Acc P.AncestralRel y → ℕ | true |
AddSubmonoid.vadd | Mathlib.Algebra.Group.Submonoid.MulAction | {M' : Type u_1} → {α : Type u_2} → [inst : AddZeroClass M'] → [VAdd M' α] → (S : AddSubmonoid M') → VAdd (↥S) α | true |
Std.Internal.IO.Process.instDecidableEqPId.decEq | Std.Internal.Async.Process | (x x_1 : Std.Internal.IO.Process.PId) → Decidable (x = x_1) | true |
Subfield.copy._proof_3 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_1} [inst : DivisionRing K] (S : Subfield K) (s : Set K) (hs : s = ↑S) {a b : K},
a ∈ (S.copy s hs).carrier → b ∈ (S.copy s hs).carrier → a + b ∈ (S.copy s hs).carrier | false |
ClosedSubmodule.toSubmodule_injective | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M], Function.Injective ClosedSubmodule.toSubmodule | true |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.scale_id_mem_verticalClosedStrip_of_mem_verticalClosedStrip._simp_1_3 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | false |
MeasureTheory.Measure.countable_meas_pos_of_disjoint_iUnion₀ | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {ι : Type u_4} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.SFinite μ]
{As : ι → Set α},
(∀ (i : ι), MeasureTheory.NullMeasurableSet (As i) μ) →
Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) As) → {i | 0 < μ (As i)}.Countable | true |
Function.Injective.groupWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.InjSurj | ∀ {G₀ : Type u_1} {G₀' : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Zero G₀'] [inst_2 : Mul G₀'] [inst_3 : One G₀']
[inst_4 : Inv G₀'] [inst_5 : Div G₀'] [inst_6 : Pow G₀' ℕ] [inst_7 : Pow G₀' ℤ] (f : G₀' → G₀)
(hf : Function.Injective f) (zero : f 0 = 0) (one : f 1 = 1) (mul : ∀ (x y : G₀'), f (x * y) = f x * f... | false |
IsLocalization'.casesOn | Mathlib.RingTheory.Localization.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{M : Submonoid R} →
{S : Type u_2} →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
{motive : IsLocalization' M S → Sort u} →
(t : IsLocalization' M S) →
((toIsLocalizationMap : M.IsLocalizationMap ⇑... | false |
RootPairing.weylGroupToPerm._proof_1 | Mathlib.LinearAlgebra.RootSystem.WeylGroup | ∀ {ι : Type u_1} {R : Type u_4} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N),
SubmonoidClass (Subgroup P.Aut) P.Aut | false |
ultrafilterBasis_is_basis | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u}, TopologicalSpace.IsTopologicalBasis (ultrafilterBasis α) | true |
LightCondensed.free._proof_1 | Mathlib.Condensed.Light.Module | ∀ (R : Type u_1) [inst : Ring R],
CategoryTheory.HasWeakSheafify (CategoryTheory.coherentTopology LightProfinite) (ModuleCat R) | false |
Equiv.Perm.disjoint_refl_iff._simp_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {f : Equiv.Perm α}, f.Disjoint f = (f = 1) | false |
CategoryTheory.instInitialCostructuredArrowOverToOver | Mathlib.CategoryTheory.Limits.Final | ∀ {C₀ : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₀]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] (F : CategoryTheory.Functor C₀ C) (X : C) [F.Initial],
(CategoryTheory.CostructuredArrow.toOver F X).Initial | true |
Lean.Server.FileWorker.RpcSession.keptAlive | Lean.Server.FileWorker.Utils | ℕ → Lean.Server.FileWorker.RpcSession → Lean.Server.FileWorker.RpcSession | true |
_private.Mathlib.Analysis.Analytic.Constructions.0.hasFPowerSeriesOnBall_inverse_one_sub._simp_1_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal}, (y ∈ Metric.eball x ε) = (edist y x < ε) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.