name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LieModuleHom.toLinearMap_comp._simp_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : AddCommGroup P] [inst_5 : Module R M]
[inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : LieRingModule L M] [inst_9 : LieRingModule L N]
[i... | false |
Lean.Elab.Tactic.ElimApp.Alt.ctorIdx | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimApp.Alt → ℕ | false |
FP.Float._sizeOf_1 | Mathlib.Data.FP.Basic | {C : FP.FloatCfg} → FP.Float → ℕ | false |
WithLp.unitization_addEquiv_prod | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | (𝕜 : Type u_1) →
(A : Type u_2) →
[inst : NormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] → [NormedSpace 𝕜 A] → WithLp 1 (Unitization 𝕜 A) ≃+ WithLp 1 (𝕜 × A) | true |
SimpleGraph.maxDegree.eq_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj],
G.maxDegree = WithBot.unbotD 0 (Finset.image (fun v => G.degree v) Finset.univ).max | true |
Finset.prod_Ico_succ_div_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} (f : ℕ → M) {m n : ℕ} [inst : CommGroup M],
m ≤ n → (∏ i ∈ Finset.Ico m (n + 1), f i) / f n = ∏ i ∈ Finset.Ico m n, f i | true |
BitVec.ushiftRight | Init.Data.BitVec.Basic | {n : ℕ} → BitVec n → ℕ → BitVec n | true |
Polygon.noConfusionType | Mathlib.Geometry.Polygon.Basic | Sort u → {P : Type u_1} → {n : ℕ} → Polygon P n → {P' : Type u_1} → {n' : ℕ} → Polygon P' n' → Sort u | false |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.ExtractClosed.shouldExtractLetValue.match_6 | Lean.Compiler.LCNF.ExtractClosed | (motive : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → motive (some decl)) →
((x : Option (Lean.Compiler.LCNF.Decl Lean.Compiler... | false |
PowerSeries.order_le | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R} (n : ℕ), (PowerSeries.coeff n) φ ≠ 0 → φ.order ≤ ↑n | true |
Matroid.delete_isBasis'_iff | Mathlib.Combinatorics.Matroid.Minor.Delete | ∀ {α : Type u_1} {M : Matroid α} {I D X : Set α}, (M.delete D).IsBasis' I X ↔ M.IsBasis' I (X \ D) | true |
Finset.mem_bipartiteBelow | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {b : β} [inst : (a : α) → Decidable (r a b)] {a : α},
a ∈ Finset.bipartiteBelow r s b ↔ a ∈ s ∧ r a b | true |
Function.Surjective.valuationRing | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [PreValuationRing R] [inst_2 : CommRing S]
[inst_3 : IsDomain S] (f : R →+* S), Function.Surjective ⇑f → ValuationRing S | true |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.coe_eq_zero_iff_of_mem_Ico._simp_1_1 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a ∈ Set.Ico a b) = (a < b) | false |
Rep.applyAsHom_apply | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} [inst : Semiring k] {G : Type v} [inst_1 : CommMonoid G] {A : Rep.{u_1, u, v} k G} (g : G) (x : ↑A),
(Rep.Hom.hom (A.applyAsHom g)) x = (A.ρ g) x | true |
closure_Iio' | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α},
(Set.Iio a).Nonempty → closure (Set.Iio a) = Set.Iic a | true |
LightProfinite.limitConeIsLimit | Mathlib.Topology.Category.LightProfinite.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[inst_1 : CategoryTheory.CountableCategory J] →
(F : CategoryTheory.Functor J LightProfinite) → CategoryTheory.Limits.IsLimit (LightProfinite.limitCone F) | true |
CategoryTheory.LiftableCocone.noConfusion | Mathlib.CategoryTheory.Limits.Creates | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{J : Type w} →
{inst_2 : CategoryTheory.Category.{w', w} J} →
{K : CategoryTheory.Functor J C} →
{F : Categ... | false |
SimpleGraph.degMatrix.congr_simp | Mathlib.Combinatorics.SimpleGraph.LapMatrix | ∀ {V : Type u_1} (R : Type u_2) [inst : Fintype V] (G G_1 : SimpleGraph V),
G = G_1 →
∀ {inst_1 : DecidableRel G.Adj} [inst_2 : DecidableRel G_1.Adj] {inst_3 : DecidableEq V} [inst_4 : DecidableEq V]
[inst_5 : AddMonoidWithOne R] (a a_1 : V),
a = a_1 → ∀ (a_2 a_3 : V), a_2 = a_3 → SimpleGraph.degMatri... | true |
ArchimedeanClass.orderHom_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : LinearOrder N] [inst_5 : IsOrderedAddMonoid N] (f : M →+o N) (a : M),
(ArchimedeanClass.orderHom f) (ArchimedeanClass.mk a) = ArchimedeanClass.mk (f a) | true |
Real.sinh_add_cosh | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sinh x + Real.cosh x = Real.exp x | true |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.mk.congr_simp | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(homEquiv homEquiv_1 : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (e_homEquiv : homEquiv = homEquiv_1)
(unit unit_1 : Ca... | true |
CategoryTheory.Functor.mapBifunctorHomologicalComplexObj | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] →
[inst_... | true |
MeasureTheory.IntegrableOn.add_measure | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s : Set α} {μ ν : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] [TopologicalSpace.PseudoMetrizableSpace ε],
MeasureTheory.IntegrableOn f s μ → MeasureTheory.IntegrableOn f s ν → MeasureTheory.IntegrableOn f s (... | true |
Polynomial.degree_freeMonic | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ) [Nontrivial R], (Polynomial.freeMonic R n).degree = ↑n | true |
IsLocalRing.ResidueField.mapEquiv._proof_6 | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R ≃+* S), IsLocalHom ↑f.symm | false |
Circle.argEquiv | Mathlib.Analysis.SpecialFunctions.Complex.Circle | Circle ≃ ↑(Set.Ioc (-Real.pi) Real.pi) | true |
Mathlib.Tactic.Widget.StringDiagram.Node.id | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.IdNode → Mathlib.Tactic.Widget.StringDiagram.Node | true |
DirichletCharacter.delta_mul | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {n : ℕ} (χ : DirichletCharacter ℂ n), (LSeries.delta * fun n_1 => χ ↑n_1) = LSeries.delta | true |
IsManifold.instOfNatWithTopENat_2 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [IsManifold I 3 M], IsManifold I 2 M | true |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MvPolynomial.idealOfVars_eq_restrictSupportIdeal._simp_1_5 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : AddSubmonoid M}
{x : M} (h : ∀ (c : R) {x : M}, x ∈ S.carrier → c • x ∈ S.carrier),
(x ∈ { toAddSubmonoid := S, smul_mem' := h }) = (x ∈ S) | false |
Localization.isLocalization_range_mapToFractionRing | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_1} (K : Type u_2) [inst : CommRing A] (S : Submonoid A) [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] (B : Type u_3) [inst_4 : CommRing B] [inst_5 : Algebra A B]
[inst_6 : IsLocalization S B] (hS : S ≤ nonZeroDivisors A),
IsLocalization S ↥(Localization.mapToFractionRing... | true |
RelSeries.toList_getElem | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) {i : ℕ} (hi : i < p.toList.length), p.toList[i] = p.toFun ⟨i, ⋯⟩ | true |
Std.IterM.length_map | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [inst_1 : Monad m]
[inst_2 : Std.IteratorLoop α m m] [Std.Iterators.Finite α m] [LawfulMonad m] [Std.LawfulIteratorLoop α m m]
{it : Std.IterM m β} {f : β → β'}, (Std.IterM.map f it).length = it.length | true |
Ideal.gc_map_comap | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S], GaloisConnection (Ideal.map f) (Ideal.comap f) | true |
exists_mem_nhds_ball_subset_of_mem_nhds | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} [inst : UniformSpace α] {a : α} {U : Set α},
U ∈ nhds a → ∃ V ∈ nhds a, ∃ t ∈ uniformity α, ∀ a' ∈ V, UniformSpace.ball a' t ⊆ U | true |
AddEquiv.addSubgroupCongr.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G} (h : H = K),
AddEquiv.addSubgroupCongr h = { toEquiv := Equiv.setCongr ⋯, map_add' := ⋯ } | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.setWidth_setWidth_succ_eq_setWidth_setWidth_of_getLsbD_false._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {i : ℕ} (k : ℕ), ¬i = k → k < i + 1 → ¬k < i → False | false |
_private.Mathlib.RingTheory.Binomial.0.Ring.smeval_ascPochhammer_int_ofNat._simp_1_3 | Mathlib.RingTheory.Binomial | ∀ {R : Type u} [inst : Semiring R] (n : ℕ), ↑n = Polynomial.C ↑n | false |
Std.DTreeMap.Internal.Impl.balanceL!.match_5.congr_eq_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3)
(l : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(ls : ℕ) →
(lk : α) →
(lv : β lk) →
(ll lr : Std.DTreeMap.Internal.Impl α β) → motive (Std.DTreeMap.I... | true |
MeasureTheory.IsHahnDecomposition.le_on | Mathlib.MeasureTheory.Measure.Decomposition.Hahn | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.IsHahnDecomposition μ ν s → μ.restrict s ≤ ν.restrict s | true |
FractionRing.algEquiv | Mathlib.RingTheory.Localization.FractionRing | (A : Type u_4) →
[inst : CommRing A] →
(K : Type u_6) → [inst_1 : CommRing K] → [inst_2 : Algebra A K] → [IsFractionRing A K] → FractionRing A ≃ₐ[A] K | true |
Subgroup.mem_smul_pointwise_iff_exists | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction α G] (m : G) (a : α)
(S : Subgroup G), m ∈ a • S ↔ ∃ s ∈ S, a • s = m | true |
BddDistLat._sizeOf_inst | Mathlib.Order.Category.BddDistLat | SizeOf BddDistLat | false |
WithCStarModule.uniformEquiv._proof_1 | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_1} [inst : UniformSpace E], IsUniformInducing ⇑(WithCStarModule.equiv A E) | false |
CompactlySupportedContinuousMap.toRealLinearMap._proof_6 | Mathlib.Topology.ContinuousMap.CompactlySupported | ContinuousConstSMul ℝ ℝ | false |
Metric.infEDist_union | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s t : Set α},
Metric.infEDist x (s ∪ t) = min (Metric.infEDist x s) (Metric.infEDist x t) | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.motive | Lean.Meta.IndPredBelow | Lean.LocalDecl → ℕ → Array Lean.FVarId → Lean.Meta.IndPredBelow.NewDecl✝ | true |
AlgebraicGeometry.Scheme.Modules.pseudofunctor_associativity_assoc | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y Z T : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ T)
{Z_1 : CategoryTheory.Functor T.Modules X.Modules}
(h_1 :
AlgebraicGeometry.Scheme.Modules.pullback
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h) ⟶
Z_1),
CategoryTheory.CategoryStruct.com... | true |
_private.Lean.Compiler.LCNF.Renaming.0.Lean.Compiler.LCNF.Param.applyRenaming.match_1 | Lean.Compiler.LCNF.Renaming | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) →
((binderName : Lean.Name) → motive (some binderName)) → ((x : Option Lean.Name) → motive x) → motive x | false |
ContinuousMultilinearMap.norm_ofSubsingleton_id_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (G : Type wG) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : Fintype ι] [inst_4 : Subsingleton ι] (i : ι),
‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖ ≤ 1 | true |
Std.Time.TimeZone.Transition.localTimeType | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.Transition → Std.Time.TimeZone.LocalTimeType | true |
CategoryTheory.categoryOfEnrichedCategoryType._proof_1 | Mathlib.CategoryTheory.Enriched.Basic | ∀ (C : Type u_2) [𝒞 : CategoryTheory.EnrichedCategory (Type u_1) C] {X Y : C} (f : X ⟶[Type u_1] Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor (X ⟶[Type u_1] Y)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (Categ... | false |
Lean.IR.IRType._sizeOf_1 | Lean.Compiler.IR.Basic | Lean.IR.IRType → ℕ | false |
CategoryTheory.StructuredArrow.commaMapEquivalenceCounitIso._proof_4 | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_2, u_6} D] {T : Type u_8} [inst_2 : CategoryTheory.Category.{u_3, u_8} T]
{L : CategoryTheory.Functor C T} {R : CategoryTheory.Functor D T} {C' : Type u_10}
[inst_3 : CategoryTheory.Category.{u_5, u_... | false |
Homotopy.mkInductiveAux₁._sunfold | Mathlib.Algebra.Homology.Homotopy | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{P Q : ChainComplex V ℕ} →
(e : P ⟶ Q) →
(zero : P.X 0 ⟶ Q.X 1) →
(one : P.X 1 ⟶ Q.X 2) →
e.f 1 =
CategoryTheory.CategoryStruct.comp (P.d 1 0) ze... | false |
Cardinal.toNat_congr | Mathlib.SetTheory.Cardinal.ToNat | ∀ {α : Type u} {β : Type v} (e : α ≃ β), Cardinal.toNat (Cardinal.mk α) = Cardinal.toNat (Cardinal.mk β) | true |
AddZero.toZero | Mathlib.Algebra.Group.Defs | {M : Type u_2} → [self : AddZero M] → Zero M | true |
_private.Lean.Meta.Tactic.FunIndInfo.0.Lean.Meta.getFunInduct?._sparseCasesOn_1 | Lean.Meta.Tactic.FunIndInfo | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Functor.RepresentableBy.recOn | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type v)} →
{Y : C} →
{motive : F.RepresentableBy Y → Sort u} →
(t : F.RepresentableBy Y) →
((homEquiv : {X : C} → (X ⟶ Y) ≃ F.obj (Opposite.op X)) →
(homEquiv_comp :
... | false |
Aesop.Script.TacticState._sizeOf_inst | Aesop.Script.TacticState | SizeOf Aesop.Script.TacticState | false |
IsEvenlyCovered.homeomorph_comp | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {I : Type u_3}
[inst_2 : TopologicalSpace I] {x : X},
IsEvenlyCovered f x I → ∀ {Y : Type u_4} [inst_3 : TopologicalSpace Y] (g : X ≃ₜ Y), IsEvenlyCovered (⇑g ∘ f) (g x) I | true |
Unitary.mapEquiv_trans | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S]
[inst_3 : StarMul S] [inst_4 : Monoid T] [inst_5 : StarMul T] (f : R ≃⋆* S) (g : S ≃⋆* T),
Unitary.mapEquiv (f.trans g) = (Unitary.mapEquiv f).trans (Unitary.mapEquiv g) | true |
Lean.Widget.DiffTag.wasDeleted.sizeOf_spec | Lean.Widget.InteractiveCode | sizeOf Lean.Widget.DiffTag.wasDeleted = 1 | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Equiv.diff_right._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 |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_32 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α),
1 ≤ (List.filter (fun x_1 => x_1 == x) (head :: tail)).length →
0 < (List.findIdxs (fun x_1 => x_1 == x) (head :: tail)).length | false |
SimpleGraph.Walk.boxProdRight.eq_1 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} (G : SimpleGraph α) {H : SimpleGraph β} {b₁ b₂ : β} (a : α),
SimpleGraph.Walk.boxProdRight G a = SimpleGraph.Walk.map (G.boxProdRight H a).toHom | true |
Equidecomp.trans_toPartialEquiv | Mathlib.Algebra.Group.Action.Equidecomp | ∀ {X : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : MulAction G X] (f g : Equidecomp X G),
(f.trans g).toPartialEquiv = f.trans g.toPartialEquiv | true |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.argsToMonoWithFnType.match_1 | Lean.Compiler.LCNF.ToMono | (motive : Option Lean.Expr → Sort u_1) →
(remainingType : Option Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (some (Lean.Expr.forallE binderName d b binderInfo))) →
((x : Option Lean.Expr) → motive x) → motive remainingType | false |
HasStrictDerivAt.hasStrictFDerivAt_equiv | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {f : 𝕜 → 𝕜} {f' x : 𝕜},
HasStrictDerivAt f f' x →
∀ (hf' : f' ≠ 0), HasStrictFDerivAt f (↑((ContinuousLinearEquiv.unitsEquivAut 𝕜) (Units.mk0 f' hf'))) x | true |
Std.ExtTreeSet.contains_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k a : α},
(t.insert k).contains a = (cmp k a == Ordering.eq || t.contains a) | true |
CategoryTheory.Limits.Multicofork.ofSigmaCofork._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : CategoryTheory.Limits.MultispanShape}
{I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left}
{hc : CategoryTheory.Limits.IsColimit c} {d : CategoryTheory.Limits.Cofan I.right}
(a : CategoryTheory.Limits.Cofork (I.... | false |
List.splitOnP_nil | Mathlib.Data.List.SplitOn | ∀ {α : Type u_1} (p : α → Bool), List.splitOnP p [] = [[]] | true |
List.permutationsAux2._sunfold | Mathlib.Data.List.Defs | {α : Type u_1} → {β : Type u_2} → α → List α → List β → List α → (List α → β) → List α × List β | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.basicOpen_eq_bot_iff._simp_1_6 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
Std.Iterators.HetT.property_liftInner | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type u_1} {m : Type w → Type w'} {n : Type w → Type w''} [inst : MonadLiftT m n] {x : Std.Iterators.HetT m α},
(Std.Iterators.HetT.liftInner n x).Property = x.Property | true |
BoundedContinuousFunction | Mathlib.Topology.ContinuousMap.Bounded.Basic | (α : Type u) → (β : Type v) → [TopologicalSpace α] → [PseudoMetricSpace β] → Type (max u v) | true |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.smul_mem_smul_iff._simp_1_3 | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Group α] [inst_1 : Monoid β] [inst_2 : MulAction α β] [SMulCommClass α β β]
[IsScalarTower α β β] (g : α) (m : β), IsUnit (g • m) = IsUnit m | false |
Std.DHashMap.Raw.WF.inter₀ | Std.Data.DHashMap.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
{h₁ : 0 < m₁.buckets.size} {h₂ : 0 < m₂.buckets.size},
m₁.WF → m₂.WF → (↑(Std.DHashMap.Internal.Raw₀.inter ⟨m₁, h₁⟩ ⟨m₂, h₂⟩)).WF | true |
AddSubmonoid.single_mem_pi._simp_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → AddZeroClass (M i)] [inst_1 : DecidableEq ι] {I : Set ι}
{S : (i : ι) → AddSubmonoid (M i)} (i : ι) (x : M i), (Pi.single i x ∈ AddSubmonoid.pi I S) = (i ∈ I → x ∈ S i) | false |
List.instLE | Init.Data.List.Basic | {α : Type u} → [LT α] → LE (List α) | true |
Asymptotics.isLittleOTVS_sup | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l₁ l₂ : Filter α} {f : α → E} {g : α → F},
f =o[𝕜; l₁ ⊔... | true |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.add_le_add_iff_right.match_1_1 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
Lean.PrettyPrinter.OneLine.State.column._default | Lean.PrettyPrinter.Formatter | ℕ | false |
groupHomology.boundaries₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{u, u, u} k G) → Submodule k (G →₀ ↑A) | true |
CategoryTheory.MorphismProperty.limitsOfShape_le | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {J : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] [W.IsStableUnderLimitsOfShape J], W.limitsOfShape J ≤ W | true |
Complex.ofReal_inv._simp_1 | Mathlib.Data.Complex.Basic | ∀ (r : ℝ), (↑r)⁻¹ = ↑r⁻¹ | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.isIso_map._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | 1 ≤ 3 | false |
SchwartzMap.toLpCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_3) {E : Type u_1} (F : Type u_2) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : MeasurableSpace E]
[inst_5 : OpensMeasurableSpace E] [inst_6 : NormedField 𝕜] [inst_7 : NormedSpace 𝕜 F] [inst_8 : SMulCommClass ℝ 𝕜 F]
[... | false |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.eval_zero_comp_det._simp_1_7 | Mathlib.RingTheory.Norm.Transitivity | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β}
{x_2 : NonAssocSemiring γ} {δ : Type u_5} {x_3 : NonAssocSemiring δ} (f : α →+* β) (g : β →+* γ) (h : γ →+* δ),
h.comp (g.comp f) = (h.comp g).comp f | false |
_private.Mathlib.Analysis.Convex.DoublyStochasticMatrix.0.convex_doublyStochastic._simp_1_2 | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {M : Matrix n n R},
(M ∈ doublyStochastic R n) = ((∀ (i j : n), 0 ≤ M i j) ∧ (∀ (i : n), ∑ j, M i j = 1) ∧ ∀ (j : n), ∑ i, M i j = 1) | false |
Lean.Elab.Term.mkCalcStepViews | Lean.Elab.Calc | Lean.TSyntax `Lean.calcSteps → Lean.Elab.TermElabM (Array Lean.Elab.Term.CalcStepView) | true |
Lean.SourceInfo.fromRef | Init.Prelude | Lean.Syntax → optParam Bool false → Lean.SourceInfo | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.all_cons._simp_1_1 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {a b : α} {s : Stream'.Seq α}, (a ∈ Stream'.Seq.cons b s) = (a = b ∨ a ∈ s) | false |
AnalyticAtWithin.compContinuousLinearMap | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {u : E →L[𝕜] F} {f : F → G} {s : Set... | true |
LinearMap.rTensor_comp | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} {Q : Type u_10}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q] (g : P →ₗ[R] Q)
... | true |
Filter.Tendsto.val_inv_units | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {N : Type u_4} [inst : TopologicalSpace N] [inst_1 : Monoid N] [inst_2 : ContinuousMul N]
[inst_3 : T2Space N] {f : ι → Nˣ} {r₁ r₂ : N} {l : Filter ι} [inst_4 : l.NeBot]
(h₁ : Filter.Tendsto (fun x => ↑(f x)) l (nhds r₁)) (h₂ : Filter.Tendsto (fun x => ↑(f x)⁻¹) l (nhds r₂)),
↑(h₁.units h₂)⁻¹ = r... | true |
pointedToBipointedSndBipointedToPointedSndAdjunction._proof_7 | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Pointed) (Y : Bipointed) (f : X ⟶ bipointedToPointedSnd.obj Y),
f.toFun X.point = (bipointedToPointedSnd.obj Y).point | false |
CategoryTheory.StrictPseudofunctorPreCore.ctorIdx | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} → {inst_1 : CategoryTheory.Bicategory C} → CategoryTheory.StrictPseudofunctorPreCore B C → ℕ | false |
SaturatedSubmonoid.instCompleteLattice._proof_3 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : MulOneClass M] (a b c : SaturatedSubmonoid M), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.