name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
StarRingEquiv.coe_refl | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} [inst : Add A] [inst_1 : Mul A] [inst_2 : Star A], ⇑StarRingEquiv.refl = id | null | true |
_private.Mathlib.Order.Atoms.0.IsSimpleOrder.equivBool._simp_1 | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : LE α] [inst_1 : BoundedOrder α] [IsSimpleOrder α], (⊥ = ⊤) = False | null | false |
Int.sign_sign | Init.Data.Int.Order | ∀ {x : ℤ}, x.sign.sign = x.sign | null | true |
Std.DTreeMap.Internal.Unit.RocSliceData._sizeOf_1 | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {inst : Ord α} → [SizeOf α] → Std.DTreeMap.Internal.Unit.RocSliceData α → ℕ | null | false |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.map_exp._simp_1_1 | Mathlib.RingTheory.Nilpotent.Exp | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | null | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.intMaxSealed_eq_intMinSealed_add._simp_1_5 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {x y z : ℕ}, (x % z = y % z) = ∃ k₁ k₂, x + k₁ * z = y + k₂ * z | null | false |
Lean.Compiler.LCNF.AlphaEqv.eqvType._f | Lean.Compiler.LCNF.AlphaEqv | (e₁ : Lean.Expr) →
Lean.Expr.below (motive := fun e₁ => Lean.Expr → Lean.Compiler.LCNF.AlphaEqv.EqvM Bool) e₁ →
Lean.Expr → Lean.Compiler.LCNF.AlphaEqv.EqvM Bool | null | false |
Lean.Meta.Match.AltLHS.mk | Lean.Meta.Match.Basic | Lean.Syntax → List Lean.LocalDecl → List Lean.Meta.Match.Pattern → Lean.Meta.Match.AltLHS | null | true |
Bimod.one_actLeft | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{A B : CategoryTheory.Mon C} (self : Bimod A B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight CategoryTheory.MonObj.one self.X) self.actLeft =
(CategoryTheory.... | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isDefEqMainImpl._sparseCasesOn_4 | Lean.Meta.Sym.Pattern | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
... | null | false |
ULift.divisionSemiring | Mathlib.Algebra.Field.ULift | {α : Type u} → [DivisionSemiring α] → DivisionSemiring (ULift.{u_1, u} α) | null | true |
CategoryTheory.PreGaloisCategory.FiberFunctor.instFaithfulFintypeCat | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {F : CategoryTheory.Functor C FintypeCat}
[inst_1 : CategoryTheory.PreGaloisCategory C] [CategoryTheory.PreGaloisCategory.FiberFunctor F], F.Faithful | Fiber functors are faithful. | true |
Matrix.one_kroneckerTMul_one | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ (R : Type u_1) {α : Type u_3} {β : Type u_5} {m : Type u_10} {n : Type u_11} [inst : CommSemiring R]
[inst_1 : AddCommMonoidWithOne α] [inst_2 : AddCommMonoidWithOne β] [inst_3 : Module R α] [inst_4 : Module R β]
[inst_5 : DecidableEq m] [inst_6 : DecidableEq n], Matrix.kroneckerMap (TensorProduct.tmul R) 1 1 = 1 | null | true |
ArithmeticFunction.ppow_zero | Mathlib.NumberTheory.ArithmeticFunction.Zeta | ∀ {R : Type u_1} [inst : Semiring R] {f : ArithmeticFunction R}, f.ppow 0 = ↑ArithmeticFunction.zeta | null | true |
coe_powMonoidWithZeroHom | Mathlib.Algebra.GroupWithZero.Hom | ∀ {M₀ : Type u_6} [inst : CommMonoidWithZero M₀] {n : ℕ} (hn : n ≠ 0), ⇑(powMonoidWithZeroHom hn) = fun x => x ^ n | null | true |
mfderiv.eq_1 | Mathlib.Geometry.Manifold.MFDeriv.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] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
SimpleGraph.killCopies_def | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {V : Type u_4} {W : Type u_5} (G : SimpleGraph V) (H : SimpleGraph W),
G.killCopies H = if hH : H = ⊥ then G else G.deleteEdges (⋃ G', ⋃ (hG' : Nonempty (H ≃g G'.coe)), {⋯.some}) | null | true |
HomologicalComplex.shortComplexFunctor'._proof_2 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_3} (c : ComplexShape ι) (i j k : ι) {X Y : HomologicalComplex C c} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (f.f i)
{ X₁ := Y.X i, X₂ := Y.X j, X₃ := Y.X k, f := Y.d i j, g := ... | null | false |
Equiv.Perm.sign_extendDomain | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u} [inst : DecidableEq α] {β : Type v} [inst_1 : Fintype α] [inst_2 : DecidableEq β] [inst_3 : Fintype β]
(e : Equiv.Perm α) {p : β → Prop} [inst_4 : DecidablePred p] (f : α ≃ Subtype p),
Equiv.Perm.sign (e.extendDomain f) = Equiv.Perm.sign e | null | true |
Polynomial.Monic.of_mul_monic_right | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, q.Monic → (p * q).Monic → p.Monic | null | true |
Matrix.instLieAlgebraToLieAlgebra._proof_3 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B] (x y : R)
(b : Matrix.ToLieAlgebra R CM), (x * y) • b = x • y • b | null | false |
CommGrpCat.limitCommGroup._proof_22 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommGrpCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommGrpCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommGrpCat))).pt), a⁻¹ * a = 1 | null | false |
Lean.ParametricAttributeImpl.preserveOrder | Lean.Attributes | {α : Type} → Lean.ParametricAttributeImpl α → Bool | If set, entries are not resorted on export and `getParam?` will fall back to a linear instead of
binary search inside an imported module's entries.
| true |
PMF.filter._proof_1 | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} (p : PMF α) (s : Set α), (∃ a ∈ s, a ∈ p.support) → tsum (s.indicator ⇑p) ≠ 0 | null | false |
IsDedekindDomain.HeightOneSpectrum.ofPrime_prime | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R),
IsDedekindDomain.HeightOneSpectrum.ofPrime ⋯ = v | null | true |
ContinuousAffineMap.decompHomeomorph_symm_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ (R : Type u_1) (V : Type u_2) {W : Type u_3} (Q : Type u_6) [inst : NormedField R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W]
[inst_6 : TopologicalSpace W] [inst_7 : AddTorsor W Q] [inst_8 : TopologicalSpace Q]
[inst_9 : IsTopolo... | null | true |
_private.Mathlib.Tactic.Peel.0.Mathlib.Tactic.Peel._aux_Mathlib_Tactic_Peel___macroRules_Mathlib_Tactic_Peel_peel_1.match_3 | Mathlib.Tactic.Peel | (motive : Option (Lean.TSyntax `term) → Sort u_1) →
(e : Option (Lean.TSyntax `term)) →
((e : Lean.TSyntax `term) → motive (some e)) → ((x : Option (Lean.TSyntax `term)) → motive x) → motive e | null | false |
Std.Tactic.BVDecide.LRAT.Parser.Text.parseNeg | Std.Tactic.BVDecide.LRAT.Parser | Std.Internal.Parsec.ByteArray.Parser ℤ | null | true |
Unitization.toProd_smul | Mathlib.Algebra.Algebra.Unitization | ∀ {S : Type u_2} {R : Type u_3} {A : Type u_4} [inst : SMul S R] [inst_1 : SMul S A] (s : S) (x : Unitization R A),
(s • x).toProd = s • x.toProd | null | true |
InnerProductSpace.isIdempotentElem_rankOne_self | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_4} {F : Type u_6} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
{x : F}, ‖x‖ = 1 → IsIdempotentElem (((InnerProductSpace.rankOne 𝕜) x) x) | null | true |
rank_le_one_iff | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {K : Type u} {V : Type v} [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Module.Free K V], Module.rank K V ≤ 1 ↔ ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v | A vector space has dimension at most `1` if and only if there is a
single vector of which all vectors are multiples. | true |
PFun.monad | Mathlib.Data.PFun | {α : Type u_1} → Monad (PFun α) | null | true |
CommMonCat.limitConeIsLimit.eq_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommMonCat)
[inst_1 : Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommMonCat)).sections],
CommMonCat.limitConeIsLimit F =
CategoryTheory.liftedLimitIsLimit
(CategoryTheory.Limits.limit.isLimit (F.comp (CategoryTh... | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.extractLsb'_extractAndExtend_eq._simp_1_4 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ}, (n < 1) = (n = 0) | null | false |
IsLocalizedModule.subsingleton_iff | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_6} {M : Type u_8} {M' : Type u_9} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (S : Submonoid R) (g : M →ₗ[R] M') [IsLocalizedModule S g],
Subsingleton M' ↔ ∀ (m : M), ∃ r ∈ S, r • m = 0 | null | true |
CategoryTheory.Functor.IsStronglyCartesian.domainIsoOfBaseIso._proof_2 | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} 𝒮] {R R' S : 𝒮} {f : R ⟶ S} {f' : R' ⟶ S} {g : R' ≅ R},
f' = CategoryTheory.CategoryStruct.comp g.hom f →
CategoryTheory.CategoryStruct.comp g.inv (CategoryTheory.CategoryStruct.comp g.hom f) =
CategoryTheory.CategoryStruct.comp g.inv f' | null | false |
Preord.of.injEq | Mathlib.Order.Category.Preord | ∀ (carrier : Type u_1) [str : Preorder carrier] (carrier_1 : Type u_1) (str_1 : Preorder carrier_1),
(↧carrier = ↧carrier_1) = (carrier = carrier_1 ∧ str ≍ str_1) | null | true |
List.IsInfix.map | Init.Data.List.Sublist | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) ⦃l₁ l₂ : List α⦄, l₁ <:+: l₂ → List.map f l₁ <:+: List.map f l₂ | null | true |
AddMonoidHom.addSubmonoidMap_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {f : M →+ N},
Function.Injective ⇑f → ∀ (M' : AddSubmonoid M), Function.Injective ⇑(f.addSubmonoidMap M') | null | true |
Multiset.map_eq_cons | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} [inst : DecidableEq α] (f : α → β) (s : Multiset α) (t : Multiset β) (b : β),
(∃ a ∈ s, f a = b ∧ Multiset.map f (s.erase a) = t) ↔ Multiset.map f s = b ::ₘ t | null | true |
Polynomial.toFinsuppIsoAlg_symm_apply_toFinsupp | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ (R : Type u) [inst : CommSemiring R] (toFinsupp : AddMonoidAlgebra R ℕ),
((Polynomial.toFinsuppIsoAlg R).symm toFinsupp).toFinsupp = toFinsupp | null | true |
CategoryTheory.LaxFunctor.map₂_leftUnitor_app | Mathlib.CategoryTheory.Bicategory.Functor.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (self : CategoryTheory.LaxFunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(self.obj a)),
(self.map₂ (CategoryTheory.Bicategory.leftUnitor f).inv).toNatTrans.app X =
CategoryTheory.CategoryStruct.comp ((self.map f).toFunctor.map ((self.mapId a).toNa... | Lax left unity. | true |
Std.Async.Sleep._sizeOf_inst | Std.Async.Timer | SizeOf Std.Async.Sleep | null | false |
InfConvergenceClass.mk | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : TopologicalSpace α],
(∀ (a : α) (s : Set α), IsGLB s a → Filter.Tendsto Subtype.val Filter.atBot (nhds a)) → InfConvergenceClass α | null | true |
Maximal.eq_1 | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} [inst : LE α] (P : α → Prop) (x : α), Maximal P x = (P x ∧ ∀ ⦃y : α⦄, P y → x ≤ y → y ≤ x) | null | true |
Lean.Lsp.SemanticTokenModifier.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokenModifier → ℕ | null | false |
Module.jacobson_le_of_eq_bot | Mathlib.RingTheory.Jacobson.Radical | ∀ {R : Type u_1} {M : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Submodule R M},
Module.jacobson R (M ⧸ N) = ⊥ → Module.jacobson R M ≤ N | null | true |
UInt32.zero_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a : UInt32}, 0 <<< a = 0 | null | true |
CategoryTheory.SmallObject.relativeCellComplexιObjFObjSuccIso | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(I : CategoryTheory.MorphismProperty C) →
(κ : Cardinal.{w}) →
[inst_1 : Fact κ.IsRegular] →
[inst_2 : OrderBot κ.ord.ToType] →
[inst_3 : I.IsCardinalForSmallObjectArgument κ] →
{X Y : C} →
... | When `ιObj I κ f` is considered as a relative `I`-cell complex,
the object at the `j`th step is obtained by applying the construction
`SmallObject.functorObj`. | true |
AddEquiv.linearEquiv_symm_apply | Mathlib.Algebra.Module.TransferInstance | ∀ {R : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid α] [inst_2 : AddCommMonoid β]
[inst_3 : Module R β] (e : α ≃+ β) (b : β), (AddEquiv.linearEquiv R e).symm b = e.symm b | null | true |
Int8.xor_comm | Init.Data.SInt.Bitwise | ∀ (a b : Int8), a ^^^ b = b ^^^ a | null | true |
Mathlib.Tactic.ClickSuggestions.Result.mk.noConfusion | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} →
{P : Sort u} →
{filtered : Option ProofWidgets.Html} →
{unfiltered : ProofWidgets.Html} →
{key : α} →
{pattern : ProofWidgets.Html} →
{filtered' : Option ProofWidgets.Html} →
{unfiltered' : ProofWidgets.Html} →
{key' : α} →
... | null | false |
Real.pi_lt_d20 | Mathlib.Analysis.Real.Pi.Bounds | Real.pi < 3.14159265358979323847 | null | true |
WeierstrassCurve.integralModel_b₈_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R K] (W : WeierstrassCurve K)
[hW : WeierstrassCurve.IsIntegral R W], (algebraMap R K) (WeierstrassCurve.integralModel R W).b₈ = W.b₈ | null | true |
Submodule.mem_stabilizer_submodule_iff_map_eq | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_4} {G : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Group G] [inst_4 : DistribMulAction G M] [inst_5 : SMulCommClass G R M] {S : Submodule R M} {e : G},
e ∈ MulAction.stabilizer G S ↔ Submodule.map (DistribSMul.toLinearMap R M e) S = S | null | true |
IsLocalization.AtPrime.equivQuotMaximalIdeal._proof_5 | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ (Rₚ : Type u_1) [inst : CommRing Rₚ] [inst_1 : IsLocalRing Rₚ],
IsLocalRing.maximalIdeal Rₚ ^ 1 = IsLocalRing.maximalIdeal Rₚ | null | false |
CategoryTheory.Limits.Pi.map_comp_map' | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : α → C} {h : β → C}
[inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct g]
[inst_3 : CategoryTheory.Limits.HasProduct h] (p : β → α) (q : (a : α) → f a ⟶ g a) (q' : (b : β) → g (p b) ⟶ h b)... | null | true |
InnerProductGeometry.norm_div_cos_angle_sub_of_inner_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
inner ℝ x y = 0 → x ≠ 0 ∨ y = 0 → ‖x‖ / Real.cos (InnerProductGeometry.angle x (x - y)) = ‖x - y‖ | A side of a right-angled triangle divided by the cosine of the adjacent angle equals the
hypotenuse, version subtracting vectors. | true |
Set.BijOn.bijective | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} (h : Set.BijOn f s t),
Function.Bijective (Set.MapsTo.restrict f s t ⋯) | null | true |
Additive.vadd | Mathlib.Algebra.Group.Action.TypeTags | {α : Type u_1} → {β : Type u_2} → [SMul α β] → VAdd (Additive α) β | null | true |
Bundle.ContinuousRiemannianMetric.toRiemannianMetric._proof_1 | Mathlib.Topology.VectorBundle.Riemannian | ∀ {B : Type u_2} [inst : TopologicalSpace B] {F : Type u_3} [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ F]
{E : B → Type u_1} [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : (b : B) → TopologicalSpace (E b)]
[inst_5 : (b : B) → AddCommGroup (E b)] [inst_6 : (b : B) → Module ℝ (E b)] [inst_... | null | false |
_private.Mathlib.RingTheory.Ideal.Quotient.HasFiniteQuotients.Basic.0.Ring.HasFiniteQuotients.instInt._proof_1 | Mathlib.RingTheory.Ideal.Quotient.HasFiniteQuotients.Basic | ∀ (n : ℤ), NeZero n → Finite (ℤ ⧸ ℤ ∙ n) | null | false |
Std.Internal.List.size_add_size_eq_size_insertList_add_size_filter_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.DistinctKeys l₂ →
l₁.length + l₂.length =
(Std.Internal.List.insertList l₁ l₂).length +
(List.filter (fun p => Std.Internal.List.containsKey p.f... | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.UniformOn.0.SummableLocallyUniformlyOn.summable.match_1_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β] (motive : SummableLocallyUniformlyOn f s → Prop)
(h : SummableLocallyUniformlyOn f s), (∀ (w : β → α) (hg : HasSumLocallyUniformlyOn f w s), motive ⋯) → motive ... | null | false |
Lean.NameSanitizerState.nameStem2Idx._default | Lean.Hygiene | Lean.NameMap ℕ | null | false |
FreeAddGroup.negRev_cons | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {a : α × Bool},
FreeAddGroup.negRev (a :: L) = FreeAddGroup.negRev L ++ FreeAddGroup.negRev [a] | null | true |
CategoryTheory.Limits.WidePullbackShape.struct._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} (j : J), none = some j → Bool.rec False True (none.ctorIdx.beq (some j).ctorIdx) | null | false |
BitVec.zero_sub | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : BitVec n), 0#n - x = -x | null | true |
MonadEvalT.monadEval | Init.Prelude | {m : Type u → Type v} → {n : Type u → Type w} → [self : MonadEvalT m n] → {α : Type u} → m α → n α | Evaluates a value from monad `m` into monad `n`. | true |
FreeAlgebra.ι | Mathlib.Algebra.FreeAlgebra | (R : Type u_3) → {X : Type u_4} → [inst : CommSemiring R] → X → FreeAlgebra R X | The canonical function `X → FreeAlgebra R X`.
| true |
Lean.IR.EmitLLVM.Context.mainFn | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} → Lean.IR.EmitLLVM.Context llvmctx → Lean.IR.FunId | null | true |
instLinearOrderWellOrderExtensionOfWellFoundedLT._proof_2 | Mathlib.Order.Extension.Well | ∀ {α : Type u_1} [inst : LT α] [h : WellFoundedLT α] (a b c : WellOrderExtension α), a ≤ b → b ≤ c → a ≤ c | null | false |
Int.fract_add_natCast | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsOrderedAddMonoid R] (a : R) (m : ℕ),
Int.fract (a + ↑m) = Int.fract a | null | true |
List.IsSuffix.getElem._proof_2 | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys : List α}, xs <:+ ys → ∀ {i : ℕ}, i < xs.length → ys.length - xs.length + i < ys.length | null | false |
NormedSpace.exp_smul | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝔸 : Type u_1} [inst : NormedRing 𝔸] [NormedAlgebra ℚ 𝔸] [CompleteSpace 𝔸] {G : Type u_3} [inst_3 : Monoid G]
[inst_4 : MulSemiringAction G 𝔸] [ContinuousConstSMul G 𝔸] (g : G) (x : 𝔸),
NormedSpace.exp (g • x) = g • NormedSpace.exp x | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt32.le_iff_lt_or_eq._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a = b) = (a.toNat = b.toNat) | null | false |
USize.size_sub_one_mod_uint16Size | Init.Data.UInt.Lemmas | (USize.size - 1) % UInt16.size = UInt16.size - 1 | null | true |
ContinuousMultilinearMap.mkPiRing.congr_simp | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (R : Type u) (ι : Type v) {M : Type u_1} [inst : Fintype ι] [inst_1 : CommRing R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : TopologicalSpace R] [inst_5 : TopologicalSpace M] [inst_6 : ContinuousMul R]
[inst_7 : ContinuousSMul R M] (z z_1 : M),
z = z_1 → ContinuousMultilinearMap.mkPiRing R ι z =... | null | true |
_private.Lean.Environment.0.Lean.Environment.mk._flat_ctor | Lean.Environment | Lean.VisibilityMap✝ Lean.Kernel.Environment →
Array Lean.EnvExtensionState →
Task Lean.Kernel.Environment →
Lean.VisibilityMap✝ Lean.AsyncConsts✝ →
Option Lean.AsyncContext✝ →
Option Lean.RealizationContext✝ →
Lean.NameMap Lean.RealizationContext✝ → Task (Lean.NameMap Lean.Asyn... | null | false |
ENNReal.iInter_Ioi_coe_nat | Mathlib.Basic.ENNReal.Basic | ⋂ n, Set.Ioi ↑n = {⊤} | null | true |
SimpleGraph.TripartiteFromTriangles.NoAccidental | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → Finset (α × β × γ) → Prop | Predicate on the triangle indices for there to be no accidental triangle.
Note that we cheat a bit, since the exact translation of this informal description would have
`(a', b', c') ∈ t` as a conclusion rather than `a = a' ∨ b = b' ∨ c = c'`. Those conditions are
equivalent when the explicit triangles are edge-disjoin... | true |
Vector.instDecidableLEOfDecidableEqOfDecidableLT | Init.Data.Vector.Lex | {α : Type u_1} → {n : ℕ} → [DecidableEq α] → [inst : LT α] → [DecidableLT α] → DecidableLE (Vector α n) | null | true |
WithSeminorms.hasBasis | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {p : SeminormFamily 𝕜 E ι},
WithSeminorms p → (nhds 0).HasBasis (fun s => s ∈ p.basisSets) id | null | true |
Set.sep_subset._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} (s : Set α) (p : α → Prop), ({x | x ∈ s ∧ p x} ⊆ s) = True | null | false |
RelIso.subrelUnivIso_apply | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} {r : α → α → Prop} {p : α → Prop} (h : ∀ (x : α), p x) (x : Subtype p), (RelIso.subrelUnivIso h) x = ↑x | null | true |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.mk.noConfusion | Std.Tactic.BVDecide.LRAT.Internal.Assignment | {P : Sort u} →
{assign assign' : Std.HashMap ℕ Std.Tactic.BVDecide.LRAT.Internal.AssignValue} →
{ assign := assign } = { assign := assign' } → (assign = assign' → P) → P | null | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_conj_iff._simp_1_3 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : (Matrix n n α)ˣ),
(↑A)⁻¹ = ↑A⁻¹ | null | false |
Shrink.instAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Shrink | ∀ {α : Type u_2} [inst : Small.{v, u_2} α] [inst_1 : AddCommMonoid α],
Shrink.instAddCommMonoid = { toAddMonoid := Shrink.instAddMonoid, add_comm := ⋯ } | null | true |
AlgebraicGeometry.ΓSpec.adjunction_counit_app | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ {R : CommRingCatᵒᵖ},
AlgebraicGeometry.ΓSpec.adjunction.counit.app R = (AlgebraicGeometry.Scheme.ΓSpecIso (Opposite.unop R)).inv.op | null | true |
Polynomial.instCommRingUniversalFactorizationRing._aux_32 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | {R : Type u_1} →
[inst : CommRing R] →
{n : ℕ} →
(m k : ℕ) →
(hn : n = m + k) →
(p : Polynomial.MonicDegreeEq R n) →
Polynomial.UniversalFactorizationRing m k hn p → Polynomial.UniversalFactorizationRing m k hn p | null | false |
CategoryTheory.Precoverage.ZeroHypercover.singleton._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C} {S T : C} (f : S ⟶ T),
CategoryTheory.Presieve.singleton f ∈ J.coverings T →
(CategoryTheory.PreZeroHypercover.singleton f).presieve₀ ∈ J.coverings T | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.«term_⊛_» | Mathlib.CategoryTheory.Monoidal.DayConvolution | Lean.TrailingParserDescr | A notation for the Day convolution of two functors. | true |
HomologicalComplex.truncLE'XIsoCycles | Mathlib.Algebra.Homology.Embedding.TruncLE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embeddi... | The isomorphism `(K.truncLE' e).X i ≅ K.cycles i'` when `e.f i = i'`
and `e.BoundaryLE i` holds. | true |
Set.insert_union | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, insert a s ∪ t = insert a (s ∪ t) | null | true |
Monotone.continuousAt_iff_leftLim_eq_rightLim | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β},
Monotone f →
∀ {x : α} [inst_4 : TopologicalSpace α] [OrderTopology α],
ContinuousAt f x ↔ Function.leftLim f x = Function.rightLim f x | A monotone function is continuous at a point if and only if its left and right limits
coincide. | true |
Representation.toCoinvariants.congr_simp | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (S : Subgroup G) [inst_4 : S.Normal],
ρ.toCoinvariants S = ρ.toCoinvariants S | null | true |
ContRepresentation.Equiv.mk''.congr_simp | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Monoid G] [inst_1 : Ring R]
[inst_2 : AddCommGroup V] [inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V]
[inst_6 : AddCommGroup W] [inst_7 : TopologicalSpace W] [inst_8 : IsTopologicalAddGroup W] [inst_9 : Modu... | null | true |
Fin.sub_succ_le_sub_of_le | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {u v : Fin (n + 2)}, u < v → v - (u + 1) < v - u | null | true |
Lean.Meta.Grind.TheoremsArray.isErased | Lean.Meta.Tactic.Grind.Theorems | {α : Type} → Lean.Meta.Grind.TheoremsArray α → Lean.Meta.Grind.Origin → Bool | null | true |
CategoryTheory.Triangulated.Octahedron.comm₁_assoc | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.