name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Unitization.instRing._proof_7 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a : Unitization R A), -a + a = 0 | null | false |
AddUnits.neg_nsmul_eq_nsmul_neg | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) (n : ℕ), ↑(-(n • a)) = n • ↑(-a) | null | true |
OreLocalization.oreDivSMulChar'.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : MulAction R X] (r₁ : R) (r₂ : X) (s₁ s₂ : ↥S),
OreLocalization.oreDivSMulChar' r₁ r₂ s₁ s₂ = ⟨OreLocalization.oreNum r₁ s₂, ⟨OreLocalization.oreDenom r₁ s₂, ⋯⟩⟩ | null | true |
Lean.Elab.Tactic.ElabSimpArgsResult | Lean.Elab.Tactic.Simp | Type | The result of elaborating a full array of simp arguments and applying them to the simp context.
| true |
Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef.mk._flat_ctor | Lean.Meta.LazyDiscrTree | {α : Type} → IO.Ref (Lean.Meta.LazyDiscrTree α) → Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef α | null | false |
MvPolynomial.zeroLocus_bot | Mathlib.RingTheory.Nullstellensatz | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Type u_3},
MvPolynomial.zeroLocus K ⊥ = ⊤ | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.apply.match_1 | Mathlib.Tactic.GRewrite.Core | (motive : Lean.Name → Sort u_1) →
(n : Lean.Name) →
(Unit → motive `Mathlib.Tactic.GCongr.exact) →
(Unit → motive `Mathlib.Tactic.GCongr.exactRefl) → ((x : Lean.Name) → motive x) → motive n | null | false |
CategoryTheory.Limits.CatCospanTransform.comp_whiskerLeft_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | true |
Nat.div_left_inj._simp_1 | Init.Data.Nat.Lemmas | ∀ {a b d : ℕ}, d ∣ a → d ∣ b → (a / d = b / d) = (a = b) | null | false |
RingCon.subsingleton_iff | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R], Subsingleton (RingCon R) ↔ Subsingleton R | null | true |
Filter.biInter_finset_mem | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} (is : Finset β), ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f | null | true |
CategoryTheory.ComposableArrows.natAddLEFunctor_obj'._proof_4 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n k l i : ℕ}, k + l ≤ n → autoParam (i ≤ l) CategoryTheory.ComposableArrows.natAddLEFunctor_obj'._auto_1 → k + i ≤ n | null | false |
CompleteBooleanAlgebra.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
[toCompleteLattice : CompleteLattice α] →
(∀ (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z) →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
(∀ (x : α), x ⊓ xᶜ ≤ ⊥) →
(∀ (x : α), ⊤ ≤ x ⊔ xᶜ) →
autoParam (∀ (x y : α), ... | null | true |
Graded.equiv | Mathlib.Algebra.GradedFunLike | {E : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : EquivLike E A B] → [GradedEquivLike E 𝒜 ... | A graded isomorphism descends to an isomorphism on each component. | true |
List.instInterOfBEq_batteries | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → Inter (List α) | null | true |
Lean.Meta.Simp.Context.simpTheorems._default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.SimpTheoremsArray | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.setWidth_ofNat_of_le_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w v x : ℕ}, ¬1 < 2 → False | null | false |
Int.gcd_mul_lcm | Init.Data.Int.Gcd | ∀ (m n : ℤ), m.gcd n * m.lcm n = m.natAbs * n.natAbs | null | true |
RelEmbedding.natLT._proof_2 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} [IsStrictOrder α r] (f : ℕ → α),
(∀ (n : ℕ), r (f n) (f (n + 1))) → ∀ ⦃a b : ℕ⦄, a < b → r (f a) (f b) | null | false |
CategoryTheory.Limits.isoZeroBiprod_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero X),
(CategoryTheory.Limits.isoZeroBiprod hY).inv = CategoryTheory.Limits.biprod.snd | null | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.eq_neg_addConst_add | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (p : Int.Internal.Linear.Poly),
Int.Internal.Linear.Poly.denote' ctx p = Int.Internal.Linear.Poly.denote' ctx (p.addConst (-p.getConst)) + p.getConst | null | true |
CategoryTheory.NatIso.pi._proof_2 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_3} {C : I → Type u_1} [inst : (i : I) → CategoryTheory.Category.{u_5, u_1} (C i)] {D : I → Type u_4}
[inst_1 : (i : I) → CategoryTheory.Category.{u_2, u_4} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)}
(e : (i : I) → F i ≅ G i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTra... | null | false |
Batteries.mkHashMap | Batteries.Data.HashMap.Basic | {α : Type u_1} → {β : Type u_2} → [inst : BEq α] → [inst_1 : Hashable α] → optParam ℕ 0 → Batteries.HashMap α β | Make a new hash map with the specified capacity. | true |
Action.FunctorCategoryEquivalence.unitIso_inv_app_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] (X : Action V G),
(Action.FunctorCategoryEquivalence.unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.V | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.detectIte._sparseCasesOn_1.else_eq | Std.Sat.AIG.CNF | ∀ {α : Type} {motive : Std.Sat.AIG.Decl α → Sort u} (t : Std.Sat.AIG.Decl α)
(gate : (l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r))
(«else» : Nat.hasNotBit 4 t.ctorIdx → motive t) (h : Nat.hasNotBit 4 t.ctorIdx),
Std.Sat.AIG.toCNF.detectIte._sparseCasesOn_1✝ t gate «else» = «else» h | null | false |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.Const.minEntry.match_1._arg_pusher | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3)
(α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → α_1 → Prop)
(x : Std.DTreeMap.Internal.Impl α fun x => β)... | null | false |
_private.Mathlib.MeasureTheory.Integral.TorusIntegral.0.term___ | Mathlib.MeasureTheory.Integral.TorusIntegral | Lean.TrailingParserDescr | null | true |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1),
(CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso C n).inv.app X =
... | null | true |
dvd_mul | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : CommSemigroup α] [DecompositionMonoid α] {k m n : α},
k ∣ m * n ↔ ∃ d₁ d₂, d₁ ∣ m ∧ d₂ ∣ n ∧ k = d₁ * d₂ | null | true |
Subsemiring.instMin._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (s t : Subsemiring R) {a b : R},
a ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier →
b ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier → a * b ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier | null | false |
Fintype.card_coe | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} (s : Finset α) [inst : Fintype ↥s], Fintype.card ↥s = s.card | null | true |
_private.Mathlib.Data.Int.Cast.Basic.0.Int.cast_neg.match_1_1 | Mathlib.Data.Int.Cast.Basic | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (_ : Unit), motive (Int.ofNat 0)) →
(∀ (n : ℕ), motive (Int.ofNat n.succ)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
Finsupp.Internal.elabSingle₀ | Mathlib.Data.Finsupp.Notation | Lean.Elab.Term.TermElab | `Finsupp` elaborator for `single₀`. | true |
Set.subset_insert_diff_singleton | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (x : α) (s : Set α), s ⊆ insert x (s \ {x}) | **Alias** of `Set.subset_insert_sdiff_singleton`. | true |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.LinearIsometryEquiv.conjStarAlgEquiv_ext_iff._simp_1_5 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_4}
... | null | false |
RestrictedProduct.mul_apply | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Mul (R i)] [inst_2 : ∀ (i : ι), MulMemClass (S i) (R i)]
(x y : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (i : ι), (x * y) i = x i * y i | null | true |
_private.Lean.Server.References.0.Lean.Server.findModuleRefs._sparseCasesOn_1 | Lean.Server.References | {motive : Lean.Lsp.RefIdent → Sort u} →
(t : Lean.Lsp.RefIdent) →
((moduleName id : String) → motive (Lean.Lsp.RefIdent.fvar moduleName id)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.slice_lt_slice_iff._simp_1_3 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
Lean.Omega.instDecidableEqConstraint.decEq.match_1 | Init.Omega.Constraint | (motive : Lean.Omega.Constraint → Lean.Omega.Constraint → Sort u_1) →
(x x_1 : Lean.Omega.Constraint) →
((a : Lean.Omega.LowerBound) →
(a_1 : Lean.Omega.UpperBound) →
(b : Lean.Omega.LowerBound) →
(b_1 : Lean.Omega.UpperBound) →
motive { lowerBound := a, upperBound := a... | null | false |
AddMonoidHom.mker.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F), AddMonoidHom.mker f = AddSubmonoid.comap f ⊥ | null | true |
Lean.ConstantKind._sizeOf_1 | Lean.Environment | Lean.ConstantKind → ℕ | null | false |
StarConvex.add_left | Mathlib.Analysis.Convex.Star | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {x : E} {s : Set E}, StarConvex 𝕜 x s → ∀ (z : E), StarConvex 𝕜 (z + x) ((fun x => z + x) '' s) | null | true |
UniqueFactorizationMonoid.of_subsingleton | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | ∀ (α : Type u_1) [inst : CommMonoidWithZero α] [Subsingleton α], UniqueFactorizationMonoid α | null | true |
PowerSeries.X_dvd_iff | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R}, PowerSeries.X ∣ φ ↔ PowerSeries.constantCoeff φ = 0 | null | true |
CategoryTheory.Limits.hasFiniteWidePullbacks_of_hasFiniteLimits | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C],
CategoryTheory.Limits.HasFiniteWidePullbacks C | Finite wide pullbacks are finite limits, so if `C` has all finite limits,
it also has finite wide pullbacks
| true |
Real.lt_pow_iff_log_lt | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y : ℝ} {n : ℕ}, 0 < x → 0 < y → (x < y ^ n ↔ Real.log x < ↑n * Real.log y) | null | true |
Char.leRefl | Init.Data.Char.Lemmas | Std.Refl fun x1 x2 => x1 ≤ x2 | null | true |
Lean.Widget.PanelWidgetsExtEntry.ctorElim | Lean.Widget.UserWidget | {motive : Lean.Widget.PanelWidgetsExtEntry → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Widget.PanelWidgetsExtEntry) →
ctorIdx = t.ctorIdx → Lean.Widget.PanelWidgetsExtEntry.ctorElimType ctorIdx → motive t | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.factorization_succ_le_sub_one | Mathlib.NumberTheory.Bernoulli | ∀ {p d : ℕ} [Fact (Nat.Prime p)], d ≥ 2 → (d + 1).factorization p ≤ d - 1 | null | true |
PeriodPair.not_continuousAt_weierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), ∀ x ∈ L.lattice, ¬ContinuousAt L.weierstrassP x | null | true |
FormalMultilinearSeries.rightInv._proof_15 | Mathlib.Analysis.Analytic.Inverse | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F | null | false |
Ideal.Quotient.instRingQuotient | Mathlib.RingTheory.Ideal.Quotient.Defs | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → Ring (R ⧸ I) | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Extended.0.FractionalIdeal.extended_ne_zero._simp_1_1 | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{I J : FractionalIdeal S P}, (I = J) = (↑I = ↑J) | null | false |
IsPurelyInseparable.instNonemptyAlgHomOfPerfectField | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [IsPurelyInseparable F E]
(L : Type u_2) [inst_4 : Field L] [PerfectField L] [inst_6 : Algebra F L], Nonempty (E →ₐ[F] L) | null | true |
Graph.bouquet_isLoopAt | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} (v : α) (edgeSet : Set β),
(Graph.bouquet v edgeSet).IsLoopAt e x ↔ e ∈ edgeSet ∧ x = v | null | true |
SSet.Truncated.ev12₂._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2} (φ : V.obj (Opposite.op { obj := { len := 2 }, property := SSet.Truncated.ι0₂._proof_3 })),
(CategoryTheory.ConcreteCategory.hom
(V.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op))
((CategoryTheory.ConcreteCategory.hom (V.map SS... | null | false |
Inclusion.InclusionM.State._sizeOf_inst | Mathlib.Tactic.Inclusion.Core.Types | SizeOf Inclusion.InclusionM.State | null | false |
IsCoveringMapOn | Mathlib.Topology.Covering.Basic | {E : Type u_1} → {X : Type u_2} → [TopologicalSpace E] → [TopologicalSpace X] → (E → X) → Set X → Prop | A covering map is a continuous function `f : E → X` with discrete fibers such that each point
of `X` has an evenly covered neighborhood. | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestImpl.evalSuggestCore._sparseCasesOn_1 | Lean.Elab.Tactic.Try | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.Grind.NatModule.mk._flat_ctor | Init.Grind.Module.Basic | {M : Type u} →
(zero : M) →
(add : M → M → M) →
(∀ (a : M), a + 0 = a) →
(∀ (a b : M), a + b = b + a) →
(∀ (a b c : M), a + b + c = a + (b + c)) →
[nsmul : SMul ℕ M] →
(∀ (a : M), 0 • a = 0) → (∀ (n : ℕ) (a : M), (n + 1) • a = n • a + a) → Lean.Grind.NatModule M | null | false |
CategoryTheory.ExponentiableMorphism.coev_ev_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I J : C} (f : I ⟶ J)
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] [inst_2 : CategoryTheory.ExponentiableMorphism f]
(Y : CategoryTheory.Over I) {Z : CategoryTheory.Over J}
(h : (CategoryTheory.ExponentiableMorphism.pushforward f).obj Y ⟶ Z),
Category... | The second triangle identity for the counit and unit of the adjunction. | true |
ContinuousLinearMap.isEmbedding_postcomp | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂]
[inst_2 : NormedField 𝕜₃] {σ : 𝕜₁ →+* 𝕜₂} {τ : 𝕜₂ →+* 𝕜₃} {ρ : 𝕜₁ →+* 𝕜₃} [inst_3 : RingHomCompTriple σ τ ρ]
{E : Type u_4} {F : Type u_5} {G : Type u_6} [inst_4 : AddCommGroup E] [inst_5 : Module 𝕜₁ E]
... | null | true |
MonoidHom.coe_prod | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : MulOneClass P]
(f : M →* N) (g : M →* P), ⇑(f.prod g) = Function.prod ⇑f ⇑g | null | true |
MeasureTheory.SimpleFunc.sup_eq_map₂ | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Max β] (f g : MeasureTheory.SimpleFunc α β),
f ⊔ g = MeasureTheory.SimpleFunc.map (fun p => p.1 ⊔ p.2) (f.pair g) | null | true |
HilbertSpace._sizeOf_inst | Mathlib.Analysis.InnerProductSpace.Defs | (𝕜 : Type u_4) →
(E : Type u_5) →
{inst : RCLike 𝕜} →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : InnerProductSpace 𝕜 E} →
{inst_3 : CompleteSpace E} → [SizeOf 𝕜] → [SizeOf E] → SizeOf (HilbertSpace 𝕜 E) | null | false |
ModuleCat.extendRestrictScalarsAdj | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] → (f : R →+* S) → ModuleCat.extendScalars f ⊣ ModuleCat.restrictScalars f | Given commutative rings `R, S` and a ring hom `f : R →+* S`, the extension and restriction of
scalars by `f` are adjoint to each other.
| true |
Algebra.SubmersivePresentation.cotangentEquiv_apply | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (x : P.toExtension.Cotangent)
(a : σ), P.cotangentEquiv x a = P.cotangentComplexAux x a | null | true |
Std.Slice.forIn_iter | Std.Data.Iterators.Lemmas.Producers.Slice | ∀ {α : Type v} {γ : Type u} {β : Type v} {m : Type w → Type x} [inst : Monad m] {δ : Type w}
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
{s : Std.Slice γ} {init : δ} {f : β → δ → m (ForInStep δ)}, forIn s.iter init f = forIn s init f | null | true |
Nat.log_pos_iff._simp_1 | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, (0 < Nat.log b n) = (b ≤ n ∧ 1 < b) | null | false |
OreLocalization.instDivisionRingNonZeroDivisors._proof_3 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : Nontrivial R] [inst_2 : NoZeroDivisors R]
[inst_3 : OreLocalization.OreSet (nonZeroDivisors R)] (a b : OreLocalization (nonZeroDivisors R) R), a / b = a * b⁻¹ | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_eq_maxKeyD._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.infEDist_eq_top_iff._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} {s : Set α}, s.Nonempty → (s = ∅) = False | null | false |
Std.TreeSet.Raw.toList_iter | Std.Data.TreeSet.Raw.Iterator | ∀ {α : Type u_1} {cmp : α → α → Ordering} (m : Std.TreeSet.Raw α cmp), m.iter.toList = m.toList | null | true |
add_tsub_cancel_left | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α]
[AddLeftReflectLE α] (a b : α), a + b - a = b | null | true |
CategoryTheory.Lax.OplaxTrans.LaxFunctor.bicategory._proof_6 | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_6) [inst_1 : CategoryTheory.Bicategory C]
{a b : CategoryTheory.LaxFunctor B C} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.Lax.OplaxTrans.whiskerLeft (CategoryTheory.CategoryStruct.id a) η =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Lax.O... | null | false |
Submodule.sndEquiv_symm_apply_coe | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (n : M₂), ↑((Submodule.sndEquiv R M M₂).symm n) = (0, n) | null | true |
IsLeftUniformGroup.completeSpace_of_weaklyLocallyCompactSpace | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_3) [inst : Group G] [inst_1 : UniformSpace G] [IsLeftUniformGroup G] [WeaklyLocallyCompactSpace G],
CompleteSpace G | A locally compact left-uniform group is complete. | true |
CategoryTheory.Pretriangulated.Triangle.instSMulHom | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} →
[inst_2 : CategoryTheory.Preadditive C] →
{R : Type u_1} →
[inst_3 : Semiring R] →
[inst_4 : CategoryTheory.Li... | null | true |
Set.card_empty | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u}, Fintype.card ↑∅ = 0 | null | true |
AddUnits.instAddZeroClass | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : AddMonoid α] → AddZeroClass (AddUnits α) | Additive units of an additive monoid have an addition and an additive identity. | true |
Lean.Meta.Context.localInstances._default | Lean.Meta.Basic | Array Lean.LocalInstance | null | false |
MeromorphicAt.meromorphicTrailingCoeffAt_of_order_eq_top | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, meromorphicOrderAt f x = ⊤ → meromorphicTrailingCoeffAt f x = 0 | If `f` is meromorphic of infinite order at `x`, the trailing coefficient is zero by definition.
| true |
Subsemigroup.isClosed_topologicalClosure | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Semigroup M] [inst_2 : SeparatelyContinuousMul M]
(s : Subsemigroup M), IsClosed ↑s.topologicalClosure | null | true |
_private.Mathlib.Algebra.Module.LocalizedModule.Basic.0.LocalizedModule.add_smul_aux | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u} [inst : CommSemiring R] {S : Submonoid R} {M : Type v} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{T : Type u_1} [inst_3 : CommSemiring T] [inst_4 : Algebra R T] [inst_5 : IsLocalization S T] (x y : T)
(p : LocalizedModule S M), (x + y) • p = x • p + y • p | null | true |
Std.HashMap.Raw.mem_modify | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k k' : α} {f : β → β}, m.WF → (k' ∈ m.modify k f ↔ k' ∈ m) | null | true |
_private.Std.Http.Data.Status.0.Std.Http.CustomStatus.ofCodeAndPhrase?._proof_1 | Std.Http.Data.Status | ∀ (code : UInt16) (phrase : String),
Std.Http.IsValidReasonPhrase phrase ∧ (100 ≤ code ∧ code ≤ 999) ∧ ¬Std.Http.isKnownStatusCode code = true →
Std.Http.IsValidReasonPhrase phrase | null | false |
EReal.toReal_zero | Mathlib.Data.EReal.Basic | EReal.toReal 0 = 0 | null | true |
Ordinal.aleph0_le_cof_iff._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {o : Ordinal.{u_1}}, (Cardinal.aleph0 ≤ o.cof) = (1 < o.cof) | null | false |
Partrec.sumCasesOn_right | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
[inst_2 : Primcodable γ] [inst_3 : Primcodable σ] {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ →. σ},
Computable f → Computable₂ g → Partrec₂ h → Partrec fun a => Sum.casesOn (f a) (fun b => Part.some (g a b)... | null | true |
HomologicalComplex₂.ιTotalOrZero | Mathlib.Algebra.Homology.TotalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{I₁₂ : Type u_4} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
(K : HomologicalComplex₂ C c₁ c₂) →
... | The inclusion of a summand in the total complex, or zero if the degrees do not match. | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trPosNum.match_1.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (motive : PosNum → Sort u_1) (n : PosNum) (h_1 : Unit → motive PosNum.one) (h_2 : (n : PosNum) → motive n.bit0)
(h_3 : (n : PosNum) → motive n.bit1),
(match n.bit0 with
| PosNum.one => h_1 ()
| n.bit0 => h_2 n
| n.bit1 => h_3 n) =
h_2 n | null | true |
Std.Roi.mem_succ_iff | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [inst_4 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.Rxi.IsAlwaysFinite α]
[Std.PRange.LawfulUpwardEnumerable α] {lo a : α},
a ∈ Std.PRange.succ lo<...* ↔ ∃ a', ... | null | true |
Set.notMem_ofPred_iff | Mathlib.Data.Set.Operations | ∀ {α : Type u} {a : α} {p : α → Prop}, a ∉ {x | p x} ↔ ¬p a | null | true |
ball_add_ball | Mathlib.Analysis.Normed.Module.Ball.Pointwise | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] {δ ε : ℝ},
0 < ε → 0 < δ → ∀ (a b : E), Metric.ball a ε + Metric.ball b δ = Metric.ball (a + b) (ε + δ) | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapShortComplexH1._simp_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
[MonoidHomClass F G H] (f : F) (a : G), (f a)⁻¹ = f a⁻¹ | null | false |
ProbabilityTheory.Kernel.lintegral_piecewise | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β}
{s : Set α} {hs : MeasurableSet s} [inst : DecidablePred fun x => x ∈ s] (a : α) (g : β → ENNReal),
∫⁻ (b : β), g b ∂(ProbabilityTheory.Kernel.piecewise hs κ η) a =
if a ∈ s then ∫⁻ (b : β), g ... | null | true |
CategoryTheory.Comonad.id_δ_app | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C),
(CategoryTheory.Comonad.id C).δ.app X = CategoryTheory.CategoryStruct.id X | null | true |
CategoryTheory.Triangulated.TStructure.noConfusion | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | {P : Sort u} →
{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}... | null | false |
SuccOrder.limitRecOn_succ_of_not_isMax | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : LinearOrder α] [inst_1 : SuccOrder α]
[inst_2 : WellFoundedLT α] (isMin : (a : α) → IsMin a → motive a)
(succ : (a : α) → ¬IsMax a → motive a → motive (Order.succ a))
(isSuccLimit : (a : α) → Order.IsSuccLimit a → ((b : α) → b < a → motive b) → motive a) (h... | null | true |
OrderRingHom.coe_orderAddMonoidHom_id | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} [inst : NonAssocSemiring α] [inst_1 : Preorder α], ↑(OrderRingHom.id α) = OrderAddMonoidHom.id α | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.