name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.MorphismProperty.Comma.mapRightEq_inv_app_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | true |
LowerSet.Iic_strictMono | Mathlib.Order.UpperLower.Principal | ∀ (α : Type u_1) [inst : Preorder α], StrictMono LowerSet.Iic | null | true |
Ideal.mulQuot._proof_1 | Mathlib.RingTheory.OrderOfVanishing.Basic | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
Lean.Meta.instHashableInfoCacheKey._private_1 | Lean.Meta.Basic | Lean.Meta.InfoCacheKey → UInt64 | null | false |
CategoryTheory.Functor.Fiber.fiberInclusion | Mathlib.CategoryTheory.FiberedCategory.Fiber | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
{p : CategoryTheory.Functor 𝒳 𝒮} → {S : 𝒮} → CategoryTheory.Functor (p.Fiber S) 𝒳 | The functor including `Fiber p S` into `𝒳`. | true |
CategoryTheory.hasExactLimitsOfShape_discrete_of_hasExactLimitsOfShape_finset_discrete_op | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteBiproducts C] [CategoryTheory.Limits.HasFiniteColimits C] (J : Type u_1)
[inst_4 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) C]
[inst_5 : CategoryTh... | `HasExactLimitsOfShape (Finset (Discrete J))ᵒᵖ C` implies `HasExactLimitsOfShape (Discrete J) C`
| true |
_private.Mathlib.Algebra.Algebra.Subalgebra.Lattice.0.Algebra.adjoin_union_coe_submodule._simp_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {N : Type u_4} [inst : CommMonoid N] {s t : Submonoid N} {x : N}, (x ∈ s ⊔ t) = ∃ y ∈ s, ∃ z ∈ t, y * z = x | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.Pattern.isInstance | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.Pattern → ℕ → Bool | Returns `true` if the `i`th argument / pattern variable is an instance. | true |
RootPairing.Hom.weight_coweight_transpose | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | true |
Lean.IR.IRType.erased.elim | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) → t.ctorIdx = 6 → motive_1 Lean.IR.IRType.erased → motive_1 t | null | false |
Batteries.Tactic.PrintPrefixConfig.showTypes._default | Batteries.Tactic.PrintPrefix | Bool | null | false |
LatticeCon.ctorIdx | Mathlib.Order.Lattice.Congruence | {α : Type u_2} → {inst : Lattice α} → LatticeCon α → ℕ | null | false |
Std.Time.Format.mk._flat_ctor | Std.Time.Format.Basic | {f : Type} →
{typ : Type → f → Type} →
((fmt : f) → typ String fmt) →
({α : Type} → (fmt : f) → typ (Option α) fmt → String → Except String α) → Std.Time.Format f typ | null | false |
CommSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | Type (u + 1) | The category of commutative semirings. | true |
CategoryTheory.Limits.map_lift_equalizerComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f g : X ⟶ Y) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D)
[inst_2 : CategoryTheory.Limits.HasEqualizer f g] [inst_3 : CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)]
{Z : C} {h : Z ⟶ X} (w :... | null | true |
Mathlib.Tactic.Translate.TranslationInfo.mk.noConfusion | Mathlib.Tactic.Translate.Core | {P : Sort u} →
{translation : Lean.Name} →
{reorder : Mathlib.Tactic.Translate.Reorder} →
{relevantArg : Mathlib.Tactic.Translate.RelevantArg} →
{translation' : Lean.Name} →
{reorder' : Mathlib.Tactic.Translate.Reorder} →
{relevantArg' : Mathlib.Tactic.Translate.RelevantArg} →
... | null | false |
CategoryTheory.Over.iteratedSliceForward_obj | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} (f : CategoryTheory.Over X)
(α : CategoryTheory.Over f),
f.iteratedSliceForward.obj α = CategoryTheory.Over.mk (CategoryTheory.Over.Hom.left α.hom) | null | true |
MeasureTheory.TendstoInMeasure.congr | Mathlib.MeasureTheory.Function.ConvergenceInMeasure | ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : EDist E]
{l : Filter ι} {f f' : ι → α → E} {g g' : α → E},
(∀ (i : ι), f i =ᵐ[μ] f' i) →
g =ᵐ[μ] g' → MeasureTheory.TendstoInMeasure μ f l g → MeasureTheory.TendstoInMeasure μ f' l g' | null | true |
Finset.add_sum_Ioo_eq_sum_Ico | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {f : α → M} {a b : α} [inst_1 : PartialOrder α]
[inst_2 : LocallyFiniteOrder α], a < b → f a + ∑ x ∈ Finset.Ioo a b, f x = ∑ x ∈ Finset.Ico a b, f x | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.equiv_of_beq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Std.DHashMap.Raw.Const.mem_alter_of_beq_eq_false | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF → (k == k') = false → (k' ∈ Std.DHashMap.Raw.Const.alter m k f ↔ k' ∈ m) | null | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.leftUnitor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.Expr → Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.StructuralAtom | The expression for the left unitor `λ_ f`. | true |
Lean.Meta.KExprMap.recOn | Lean.Meta.KExprMap | {α : Type} →
{motive : Lean.Meta.KExprMap α → Sort u} →
(t : Lean.Meta.KExprMap α) →
((map : Lean.PHashMap Lean.HeadIndex (Lean.AssocList Lean.Expr α)) → motive { map := map }) → motive t | null | false |
Std.TreeMap.minKey?_le_of_contains | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k km : α}
(hc : t.contains k = true), t.minKey?.get ⋯ = km → (cmp km k).isLE = true | null | true |
Filter.Tendsto.finInit | Mathlib.Topology.Constructions | ∀ {Y : Type v} {n : ℕ} {A : Fin (n + 1) → Type u_9} [inst : (i : Fin (n + 1)) → TopologicalSpace (A i)]
{f : Y → (j : Fin (n + 1)) → A j} {l : Filter Y} {x : (j : Fin (n + 1)) → A j},
Filter.Tendsto f l (nhds x) → Filter.Tendsto (fun a => Fin.init (f a)) l (nhds (Fin.init x)) | null | true |
CoassocSimps.lid_comp_map_assoc | Mathlib.RingTheory.Coalgebra.CoassocSimps | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {P : Type u_5} {M' : Type u_6} [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R P] [inst_7 : AddCommMonoid M'] [inst_8 : Module R M'] (f : M →ₗ[R] R)
... | null | true |
Algebra.PreSubmersivePresentation.jacobian_ofAlgEquiv | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.PreSubmersivePresentation R S ι σ) {T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T]
(e : S ≃ₐ[R] T) [inst_5 : Finite σ], (P.ofAlgEquiv e).jacobian = e P.jacobian | null | true |
CategoryTheory.AddMonObj.add_comp_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X : C} [inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.AddMonObj N] (f₁ f₂ : X ⟶ M) (g : M ⟶ N)
[CategoryTheory.IsAddMonHom g] {Z : C} (h : N ⟶ Z),
CategoryTheory.CategoryStruct.c... | null | true |
Lean.Exception.internal.elim | Lean.Exception | {motive : Lean.Exception → Sort u} →
(t : Lean.Exception) →
t.ctorIdx = 1 →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive t | null | false |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Lift.0.SkewMonoidAlgebra.domCongr._simp_1 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_4} {G'' : Type u_5} (f : G ≃ G') (g : G' ≃ G'')
(l : SkewMonoidAlgebra k G),
SkewMonoidAlgebra.equivMapDomain g (SkewMonoidAlgebra.equivMapDomain f l) =
SkewMonoidAlgebra.equivMapDomain (f.trans g) l | null | false |
_private.Init.Data.String.Basic.0.String.Pos.lt_of_le_of_ne._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | null | false |
_private.Mathlib.Order.Filter.Map.0.Filter.frequently_comap._simp_1_2 | Mathlib.Order.Filter.Map | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
Lean.LibrarySuggestions.Config._sizeOf_inst | Lean.LibrarySuggestions.Basic | SizeOf Lean.LibrarySuggestions.Config | null | false |
AdicCompletion.of_ofAlgEquiv_symm | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_5} [inst : CommRing S] (I : Ideal S) [inst_1 : IsAdicComplete I S] (x : AdicCompletion I S),
(AdicCompletion.of I S) ((AdicCompletion.ofAlgEquiv I).symm x) = x | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.processArrayLit | Lean.Meta.Match.Match | Lean.Meta.Match.Problem → Lean.MetaM (Array Lean.Meta.Match.Problem) | null | true |
Lean.Meta.AbstractMVars.instMonadMCtxM | Lean.Meta.AbstractMVars | Lean.MonadMCtx Lean.Meta.AbstractMVars.M | null | true |
LinearMap.cancel_right | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | true |
FirstOrder.Language.Formula | Mathlib.ModelTheory.Syntax | FirstOrder.Language → Type u' → Type (max u v u') | `Formula α` is the type of formulas with free variables indexed by `α` and no bound variables in
scope. | true |
TopologicalGroup.IsSES.inducedMeasure._proof_2 | Mathlib.MeasureTheory.Measure.Haar.Extension | ContinuousConstSMul ℝ ℝ | null | false |
CategoryTheory.Abelian.SpectralObject.isoMapFourδ₁Toδ₀'_hom_inv_id_assoc | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι' : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : Preorder ι'] (X' : CategoryTheory.Abelian.SpectralObject C ι') (i₀ i₁ i₂ i₃ i₄ : ι') (hi₀₁ : i₀ ≤ i₁)
(hi₁₂ : i₁ ≤ i₂) (hi₂₃ : i₂ ≤ i₃) (hi₃₄ : i₃ ≤ i₄) (n₀ n₁ n₂ : ℤ)
(h : CategoryTheory.L... | null | true |
Lean.Expr.bvarIdx? | Mathlib.Lean.Expr.Basic | Lean.Expr → Option ℕ | null | true |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.encard_maximalSeparatedSet._proof_1_4 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal},
Metric.packingNumber ε A ≠ ⊤ → (Metric.maximalSeparatedSet ε A).encard = Metric.packingNumber ε A | null | false |
MeasureTheory.Measure.restrict_mono_measure | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {x : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
μ ≤ ν → ∀ (s : Set α), μ.restrict s ≤ ν.restrict s | null | true |
OptionT.instAlternativeMonadOfMonad | Batteries.Control.AlternativeMonad | (m : Type u_1 → Type u_2) → [Monad m] → AlternativeMonad (OptionT m) | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.Transcendental.0.lift_trdeg_add_le._simp_1_1 | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ (α : Type u) (β : Type v),
Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) = Cardinal.mk (α ⊕ β) | null | false |
Ideal.mapCotangent | Mathlib.RingTheory.Ideal.Cotangent | {R : Type u} →
[inst : CommRing R] →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CommRing A] →
[inst_2 : CommRing B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
(I₁ : Ideal A) →
(I₂ : Ideal B) → (f : A →ₐ[R] B) → I₁ ≤ Idea... | The map `I/I² → J/J²` if `I ≤ f⁻¹(J)`. | true |
FiniteDimensional.of_isCompact_closedBall₀ | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ (𝕜 : Type u) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {V : Type u_1} [inst_2 : NormedAddCommGroup V]
[inst_3 : Module 𝕜 V] [ContinuousSMul 𝕜 V] {r : ℝ}, 0 < r → IsCompact (Metric.closedBall 0 r) → FiniteDimensional 𝕜 V | **Riesz's theorem**: if a closed ball with center zero of positive radius is compact in a vector
space, then the space is finite-dimensional. | true |
Ordnode.split3._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α × Option α × Ordnode α | null | false |
Lean.Lsp.RpcWireFormat.v1.elim | Lean.Server.Rpc.Basic | {motive : Lean.Lsp.RpcWireFormat → Sort u} →
(t : Lean.Lsp.RpcWireFormat) → t.ctorIdx = 1 → motive Lean.Lsp.RpcWireFormat.v1 → motive t | null | false |
Std.DTreeMap.Internal.Impl.getKeyD._f | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} → [Ord α] → α → α → (t : Std.DTreeMap.Internal.Impl α β) → Std.DTreeMap.Internal.Impl.below t → α | null | false |
Cardinal.lt_aleph0_iff_finite | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u}, Cardinal.mk α < Cardinal.aleph0 ↔ Finite α | null | true |
Matrix.trace_zero | Mathlib.LinearAlgebra.Matrix.Trace | ∀ (n : Type u_3) (R : Type u_6) [inst : Fintype n] [inst_1 : AddCommMonoid R], Matrix.trace 0 = 0 | null | true |
CommAlgCat.binaryCofanIsColimit._proof_4 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (A : CommAlgCat R), IsScalarTower R R ↑A | null | false |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.PowerSeries.coeff_one_pow._simp_1_5 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
RootPairing.root | Mathlib.LinearAlgebra.RootSystem.Defs | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → [inst_3 : AddCommGroup N] → [inst_4 : Module R N] → RootPairing ι R M N → ι ↪ M | A parametrized family of vectors, called roots. | true |
_private.Mathlib.Data.Int.Basic.0.Int.natCast_dvd._simp_1_2 | Mathlib.Data.Int.Basic | ∀ {a b : ℤ}, (a ∣ -b) = (a ∣ b) | null | false |
Turing.ListBlank.tail_mk | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), (Turing.ListBlank.mk l).tail = Turing.ListBlank.mk l.tail | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.0._regBuiltin.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_extractLsb'_not.declare_198._@.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.2283078798._hygCtx._hyg.24 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | IO Unit | null | false |
CategoryTheory.Mat_.instAddCommGroupHom._proof_20 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(M N : CategoryTheory.Mat_ C),
autoParam
(∀ (n : ℕ) (a : M ⟶ N),
CategoryTheory.Mat_.instAddCommGroupHom._aux_17 M N (↑n.succ) a =
CategoryTheory.Mat_.instAddCommGroupHom._aux_17 M N (↑n) a + a)
... | null | false |
Mathlib.Meta.FunProp.FunctionTheorem.appliedArgs | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.FunctionTheorem → ℕ | total number of arguments applied to the function | true |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.rayleighQuotient_le_of_mem_resolventSet._proof_1_5 | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
ContinuousConstSMul 𝕜 E | null | false |
Nat.one_eq_digitChar | Init.Data.Nat.ToString | ∀ {n : ℕ}, '1' = n.digitChar ↔ n = 1 | null | true |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_3 | Lean.Meta.LitValues | (motive : Option ((n : ℕ) × Fin n) → Sort u_1) →
(__do_lift : Option ((n : ℕ) × Fin n)) →
((fst : ℕ) → (n : Fin fst) → motive (some ⟨fst, n⟩)) →
((x : Option ((n : ℕ) × Fin n)) → motive x) → motive __do_lift | null | false |
RestrictedProduct.instNSMul | 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 : ι) → AddMonoid (R i)] →
[∀ (i : ι), AddSubmonoidClass (S i) (R i)] → SMul ℕ (RestrictedProduct (fun i => R i)... | null | true |
Lean.Grind.eq_true_of_and_eq_true_right | Init.Grind.Lemmas | ∀ {a b : Prop}, (a ∧ b) = True → b = True | null | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.remainingBytes.match_1 | Init.Data.String.Iterator | (motive : String.Legacy.Iterator → Sort u_1) →
(x : String.Legacy.Iterator) → ((s : String) → (i : String.Pos.Raw) → motive { s := s, i := i }) → motive x | null | false |
MeasureTheory.L1.integral_def | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_5} {E : Type u_6} [inst : NormedAddCommGroup E] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E], MeasureTheory.L1.integral = ⇑MeasureTheory.L1.integralCLM | null | true |
Matrix.cons_transpose | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {m : ℕ} {n' : Type uₙ} (v : n' → α) (A : Matrix (Fin m) n' α),
(Matrix.of (Matrix.vecCons v A)).transpose = Matrix.of fun i => Matrix.vecCons (v i) (A.transpose i) | null | true |
SeparationQuotient.lift₂.congr_simp | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} {α : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(f f_1 : X → Y → α) (e_f : f = f_1)
(hf : ∀ (a : X) (b : Y) (c : X) (d : Y), Inseparable a c → Inseparable b d → f a b = f c d)
(a a_1 : SeparationQuotient X),
a = a_1 →
∀ (a_2 a_3 : SeparationQuotient Y... | null | true |
LowerSet.instCommMonoid._proof_4 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (x : LowerSet α),
npowRecAuto 0 x = 1 | null | false |
Lean.Plugin.noConfusion | Lean.Setup | {P : Sort u} → {t t' : Lean.Plugin} → t = t' → Lean.Plugin.noConfusionType P t t' | null | false |
CategoryTheory.Functor.CommShift.mk | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{A : Type u_6} →
[inst_2 : AddMonoid A] →
[inst_3 : CategoryTheory.HasShift C A] →
... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.ordered_keys_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
instAddCommMonoidUniformFun._proof_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid β] (a b : UniformFun α β), a + b = b + a | null | false |
Sym2.fromRel.decidablePred._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} (sym : Std.Symm r) (a b : α), Subsingleton (Decidable (s(a, b) ∈ Sym2.fromRel sym)) | null | false |
Int.Cooper.le_zero_resolve_left | Init.Data.Int.Cooper | ∀ (a c d p x : ℤ), p ≤ a * x → 0 ≤ Int.Cooper.resolve_left a c d p x | `resolve_left` is nonnegative when `p ≤ a * x`. | true |
_private.Mathlib.Computability.AkraBazzi.GrowsPolynomially.0.AkraBazziRecurrence.GrowsPolynomially.eventually_zero_of_frequently_zero._proof_1_4 | Mathlib.Computability.AkraBazzi.GrowsPolynomially | ∀ (k : ℕ), -↑k - 1 ≤ -↑k | null | false |
WeierstrassCurve.Jacobian.Point.zero_def | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [inst_1 : Nontrivial R],
0 = { point := ⟦![1, 1, 0]⟧, nonsingular := ⋯ } | null | true |
Std.Http.Method.pri.sizeOf_spec | Std.Http.Data.Method | sizeOf Std.Http.Method.pri = 1 | null | true |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass | Mathlib.CategoryTheory.Abelian.Injective.Ext | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
{X Y : C} →
(R : CategoryTheory.InjectiveResolution Y) →
{n : ℕ} →
CategoryTheory.Abelian.Ext X Y n ≃
CochainCompl... | If `R` is an injective resolution of `Y`, then `Ext X Y n` identifies
to the type of cohomology classes of degree `n` from `(singleFunctor C 0).obj X`
to `R.cochainComplex`. | true |
QPF.mk.noConfusion | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type v} →
{P : Sort u_1} →
{toFunctor : Functor F} →
{P_1 : PFunctor.{u, u'}} →
{abs : {α : Type u} → ↑P_1 α → F α} →
{repr : {α : Type u} → F α → ↑P_1 α} →
{abs_repr : ∀ {α : Type u} (x : F α), abs (repr x) = x} →
{abs_map : ∀ {α β : Type u} (f : α ... | null | false |
TestFunction.instAddCommGroup._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (a b c : TestFunction Ω F n),
a + b + c = a + (b + c) | null | false |
CategoryTheory.PreZeroHypercover.bind_f | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {T : C} (E : CategoryTheory.PreZeroHypercover T)
(F : (i : E.I₀) → CategoryTheory.PreZeroHypercover (E.X i)) (ij : (i : E.I₀) × (F i).I₀),
(E.bind F).f ij = CategoryTheory.CategoryStruct.comp ((F ij.fst).f ij.snd) (E.f ij.fst) | null | true |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.checkConstant | Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr | Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.RingM Bool | Returns `true` if `c.p` is the constant polynomial. | true |
CategoryTheory.Abelian.SpectralObject.liftE_ιE_fromOpcycles._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
Lean.Lsp.instFromJsonClientInfo | Lean.Data.Lsp.InitShutdown | Lean.FromJson Lean.Lsp.ClientInfo | null | true |
IO.Error.mkResourceExhaustedFile | Init.System.IOError | String → UInt32 → String → IO.Error | null | true |
MulAction.IsPreprimitive.of_surjective | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {M : Type u_3} [inst : Group M] {α : Type u_4} [inst_1 : MulAction M α] {N : Type u_5} {β : Type u_6}
[inst_2 : Group N] [inst_3 : MulAction N β] {φ : M → N} {f : α →ₑ[φ] β} [MulAction.IsPreprimitive M α],
Function.Surjective ⇑f → MulAction.IsPreprimitive N β | null | true |
Std.DTreeMap.Raw.Const.get!_diff | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β],
m₁.WF →
m₂.WF →
∀ {k : α},
Std.DTreeMap.Raw.Const.get! (m₁ \ m₂) k =
if m₂.contains k = true then default else Std.DTreeMap.Raw.Const.get! m₁ k | null | true |
abs_sub_sup_add_abs_sub_inf | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b c : α),
|a ⊔ c - b ⊔ c| + |a ⊓ c - b ⊓ c| = |a - b| | null | true |
CategoryTheory.pullbackShiftIso | Mathlib.CategoryTheory.Shift.Pullback | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u_2} →
{B : Type u_3} →
[inst_1 : AddMonoid A] →
[inst_2 : AddMonoid B] →
[inst_3 : CategoryTheory.HasShift C B] →
(φ : A →+ B) →
(a : A) →
(b : B) →
... | When `b = φ a`, this is the canonical
isomorphism `shiftFunctor (PullbackShift C φ) a ≅ shiftFunctor C b`. | true |
Sigma.isPreconnected_iff | Mathlib.Topology.Connected.Clopen | ∀ {ι : Type u_1} {X : ι → Type u_2} [hι : Nonempty ι] [inst : (i : ι) → TopologicalSpace (X i)]
{s : Set ((i : ι) × X i)}, IsPreconnected s ↔ ∃ i t, IsPreconnected t ∧ s = Sigma.mk i '' t | null | true |
Module.Basis.constr_basis | Mathlib.LinearAlgebra.Basis.Defs | ∀ {M' : Type u_7} [inst : AddCommMonoid M'] {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst_1 : Semiring R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (b : Module.Basis ι R M) [inst_4 : Module R M'] (S : Type u_13)
[inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M')... | null | true |
_private.Lean.Meta.Tactic.Cbv.Main.0.Lean.Meta.Tactic.Cbv.handleProj.match_1 | Lean.Meta.Tactic.Cbv.Main | (motive : Option Lean.Expr → Sort u_1) →
(__x : Option Lean.Expr) →
((reduced : Lean.Expr) → motive (some reduced)) → ((x : Option Lean.Expr) → motive x) → motive __x | null | false |
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : Inhabited α]
(h : t.WF) {l : List α} {k : α},
k ∈ t → (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)).getKey! k = t.getKey! k | null | true |
CategoryTheory.Limits.createsColimitUnop | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {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 : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) →
... | If `F : Cᵒᵖ ⥤ Dᵒᵖ` creates limits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` creates
colimits of `K : J ⥤ C`. | true |
CategoryTheory.Reflective.comparison_full | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{R : CategoryTheory.Functor D C} [R.Full] {L : CategoryTheory.Functor C D} (adj : L ⊣ R),
(CategoryTheory.Monad.comparison adj).Full | null | true |
Finpartition.mem_part_ofSetSetoid_iff_rel | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Setoid α} (x : Finset α) [inst_1 : DecidableRel ⇑s] {b : α},
b ∈ (Finpartition.ofSetSetoid s x).part a ↔ a ∈ x ∧ b ∈ x ∧ s a b | null | true |
_private.Mathlib.Probability.Process.LocalProperty.0.ProbabilityTheory.isPreLocalizingSequence_of_isLocalizingSequence_aux | Mathlib.Probability.Process.LocalProperty | ∀ {ι : Type u_1} {Ω : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : ConditionallyCompleteLinearOrderBot ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι]
{𝓕 : MeasureTheory.Filtration ι mΩ} [SecondCountableTopology ι] [MeasureTheory.IsFiniteMeasure P]
{τ : ℕ → Ω → WithTop ι} ... | null | true |
FractionalIdeal.count_coe_nonneg | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R) (J : Ideal R),
0 ≤ FractionalIdeal.count K v ↑J | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.