name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Valuation.IsNontrivial_iff_exists_one_lt | Mathlib.RingTheory.Valuation.Basic | ∀ {K : Type u_7} [inst : DivisionRing K] {Γ₀ : Type u_8} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
{v : Valuation K Γ₀}, v.IsNontrivial ↔ ∃ x, 1 < v x | null | true |
MaxTropical.mulLeftMono | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LE R] [inst_1 : Add R] [AddLeftMono R], MulLeftMono (MaxTropical R) | null | true |
RootPairing.reflection_inv | 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] (P : RootPairing ι R M N) (i : ι),
(P.reflection i)⁻¹ = P.reflection i | null | true |
_private.Lean.Compiler.MetaAttr.0.Lean.initFn._@.Lean.Compiler.MetaAttr.358778973._hygCtx._hyg.2 | Lean.Compiler.MetaAttr | IO (Lean.SimplePersistentEnvExtension Lean.Name Lean.NameSet) | null | false |
CategoryTheory.Functor.ShiftSequence.leftComp._proof_2 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {D : Type u_7} {A : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_7} D] [inst_2 : CategoryTheory.Category.{u_2, u_3} A]
{π : CategoryTheory.Functor C D} {H : CategoryTheory.Functor D A} (M : Type u_5) [inst_3 : AddMonoid M]
[inst_4 : CategoryThe... | null | false |
MeasureTheory.Filtration.IsRightContinuous | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
{ι : Type u_2} → {m : MeasurableSpace Ω} → [inst : PartialOrder ι] → MeasureTheory.Filtration ι m → Prop | A filtration `𝓕` is right continuous if it is equal to its right continuation `𝓕₊`. | true |
Aesop.instInhabitedForwardRulePriority.default | Aesop.Rule.Forward | Aesop.ForwardRulePriority | null | true |
Set.image_sdiff | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ (s t : Set α), f '' (s \ t) = f '' s \ f '' t | null | true |
List.getLast_eq_getElem._f | Init.Data.List.Lemmas | ∀ {α : Type u_1} (x : List α) (f : List.below (motive := fun x => ∀ (x_1 : x ≠ []), x.getLast x_1 = x[x.length - 1]) x)
(x_1 : x ≠ []), x.getLast x_1 = x[x.length - 1] | null | false |
MulEquiv.arrowCongr._proof_2 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_4} {N : Type u_1} {P : Type u_3} {Q : Type u_2} [inst : Mul P] [inst_1 : Mul Q] (f : M ≃ N) (g : P ≃* Q)
(k : N → Q), (fun h n => g (h (f.symm n))) ((fun k m => g.symm (k (f m))) k) = k | null | false |
OmegaCompletePartialOrder.Chain.pair_succ | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} [inst : Preorder α] (a b : α) (hab : a ≤ b) (n : ℕ),
(OmegaCompletePartialOrder.Chain.pair a b hab) (n + 1) = b | null | true |
groupCohomology.map_one_snd_of_isCocycle₂ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Monoid G] [inst_1 : AddCommGroup A] [inst_2 : MulAction G A] {f : G × G → A},
groupCohomology.IsCocycle₂ f → ∀ (g : G), f (g, 1) = g • f (1, 1) | null | true |
_private.Mathlib.Algebra.Order.SuccPred.0.Order.IsPredPrelimit.lt_sub_natCast.match_1_1 | Mathlib.Algebra.Order.SuccPred | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Filter.EventuallyEq.eventuallyEq_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {α : Type u_1} {x : X} {f g : X → α},
f =ᶠ[nhds x] g → ∀ᶠ (y : X) in nhds x, f =ᶠ[nhds y] g | If two functions are equal in a neighbourhood of `x`, then for `y` sufficiently close
to `x` these functions are equal in a neighbourhood of `y`. | true |
AlgebraicGeometry.IsImmersion.instDiagonalScheme | Mathlib.AlgebraicGeometry.Morphisms.Immersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
AlgebraicGeometry.IsImmersion (CategoryTheory.Limits.pullback.diagonal f) | The diagonal morphism is always an immersion. | true |
CategoryTheory.Limits.hasZeroMorphismsOpposite._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : Cᵒᵖ} (f : X ⟶ Y) (Z : Cᵒᵖ), CategoryTheory.CategoryStruct.comp f 0 = 0 | null | false |
String.Slice.Pattern.ToForwardSearcher.defaultImplementation | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[String.Slice.Pattern.ForwardPattern pat] →
String.Slice.Pattern.ToForwardSearcher pat (String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat) | The default implementation of `ToForwardSearcher` repeatedly tries to match the pattern using
the given `ForwardPattern` instance.
It is sometimes possible to give a more efficient implementation; see `ToForwardSearcher`
for more details.
| true |
Monotone.monotone_iterate_of_le_map | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x : α}, Monotone f → x ≤ f x → Monotone fun n => f^[n] x | If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
a monotone sequence. | true |
Derivation.compAEval_apply | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M]
(d : Derivation R A M) (a : A) (f : Polynomial R),
(d.compAEval a) f = (Module.AEval.of R M ... | null | true |
singleton_mul_ball | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x y : E), {x} * Metric.ball y δ = Metric.ball (x * y) δ | null | true |
Std.HashMap.getKey?_filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α},
(Std.HashMap.filterMap f m).getKey? k = (m.getKey? k).pfilter fun x_2 h' => (f x_2 m[x_2]).isSome | null | true |
T5Space.toT1Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u} {inst : TopologicalSpace X} [self : T5Space X], T1Space X | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.assoc_induction.match_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : List ((a : α) × β a) → Prop) (x : List ((a : α) × β a)),
(∀ (_ : Unit), motive []) →
(∀ (fst : α) (snd : β fst) (tail : List ((a : α) × β a)), motive (⟨fst, snd⟩ :: tail)) → motive x | null | false |
Lean.Parser.Tactic.MRefinePat.brecOn.eq | Std.Tactic.Do.Syntax | ∀ {motive_1 : Lean.Parser.Tactic.MRefinePat → Sort u} {motive_2 : List Lean.Parser.Tactic.MRefinePat → Sort u}
(t : Lean.Parser.Tactic.MRefinePat) (F_1 : (t : Lean.Parser.Tactic.MRefinePat) → t.below → motive_1 t)
(F_2 : (t : List Lean.Parser.Tactic.MRefinePat) → Lean.Parser.Tactic.MRefinePat.below_1 t → motive_2 t... | null | true |
Filter.inv_pure | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Inv α] {a : α}, (pure a)⁻¹ = pure a⁻¹ | null | true |
CategoryTheory.CartesianMonoidalCategory.prodComparisonIso_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₁} [inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) (A B : C) {E : Type u₂} [inst_4 : CategoryTheory.Category.... | null | true |
Std.DHashMap.Internal.Raw₀.Const.foldM_eq_foldlM_toArray | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {δ : Type w} {m' : Type w → Type w'} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst : Monad m'] [LawfulMonad m'] {f : δ → α → β → m' δ} {init : δ},
Std.DHashMap.Raw.foldM f init ↑m = Array.foldlM (fun a b => f a b.1 b.2) init (Std.DHashMap.Raw.Const.toArray ↑m) | null | true |
Function.HasFiniteSupport.sumMk | Mathlib.Algebra.FiniteSupport.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] {M' : Type u_3} [inst_1 : Zero M'] {f : α → M} {g : α → M'},
Function.HasFiniteSupport f → Function.HasFiniteSupport g → Function.HasFiniteSupport fun a => (f a, g a) | null | true |
IsDedekindDomain.HeightOneSpectrum.count_normalizedFactors_eq_multiplicity | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_3} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {I : Ideal R},
I ≠ ⊥ →
∀ (p : IsDedekindDomain.HeightOneSpectrum R),
Multiset.count p.asIdeal (UniqueFactorizationMonoid.normalizedFactors I) = multiplicity p.asIdeal I | Normalize the multiplicity of a prime ideal `p` in the factorization of `I`
as `multiplicity p.asIdeal I`. | true |
AddSubmonoid.mul_subset_mul | Mathlib.Algebra.Ring.Submonoid.Pointwise | ∀ {R : Type u_2} [inst : NonUnitalNonAssocSemiring R] {M N : AddSubmonoid R}, ↑M * ↑N ⊆ ↑(M * N) | null | true |
List.getElem_cons_drop | Init.GetElem | ∀ {α : Type u_1} {as : List α} {i : ℕ} (h : i < as.length), as[i] :: List.drop (i + 1) as = List.drop i as | null | true |
List.findSomeRev?_eq_findSome?_reverse | Init.Data.List.Impl | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : α → Option β}, List.findSomeRev? f l = List.findSome? f l.reverse | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofZeroDvd.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr),
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofZeroDvd c = Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofZeroDvd c_1) =
(c = c_1) | null | true |
TopologicalSpace.IrreducibleCloseds.map._proof_2 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : β → α)
(c : TopologicalSpace.IrreducibleCloseds β), IsClosed (closure (f '' ↑c)) | null | false |
CategoryTheory.Functor.LeftLinear.casesOn | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Mo... | null | false |
Lean.Parser.Term.structInstField.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
toDual_comp_gradientWithin | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {s : Set F},
⇑(InnerProductSpace.toDual 𝕜 F) ∘ gradientWithin f s = fderivWithin 𝕜 f s | null | true |
Aesop.SafeRulesResult.proved.injEq | Aesop.Search.Expansion | ∀ (newRapps newRapps_1 : Array Aesop.RappRef),
(Aesop.SafeRulesResult.proved newRapps = Aesop.SafeRulesResult.proved newRapps_1) = (newRapps = newRapps_1) | null | true |
ModuleCat.MonModuleEquivalenceAlgebra.MonObj.toRing._proof_17 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : ModuleCat R) (a b : ↑A), a - b = a + -b | null | false |
CategoryTheory.ProjectiveResolution.Hom.noConfusion | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroObject C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{Z : C} →
{P_1 : CategoryTheory.ProjectiveResolution Z} →
{Z' : C} →
... | null | false |
UInt8.toUInt16_ofNatClamp_of_lt | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt8.size), (UInt8.ofNatClamp n).toUInt16 = UInt16.ofNatLT n ⋯ | null | true |
CompleteDistribLattice.MinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | (α : Type u) → [CompleteLattice α] → Prop | Structure containing the minimal axioms required to check that an order is a complete
distributive lattice. Do NOT use, except for implementing `CompleteDistribLattice` via
`CompleteDistribLattice.ofMinimalAxioms`.
This structure omits the `himp`, `compl`, `sdiff`, `hnot` fields, which can be recovered using
`Complete... | true |
Aesop.RuleTacDescr.cases.injEq | Aesop.RuleTac.Descr | ∀ (target : Aesop.CasesTarget) (md : Lean.Meta.TransparencyMode) (isRecursiveType : Bool)
(ctorNames : Array Aesop.CtorNames) (target_1 : Aesop.CasesTarget) (md_1 : Lean.Meta.TransparencyMode)
(isRecursiveType_1 : Bool) (ctorNames_1 : Array Aesop.CtorNames),
(Aesop.RuleTacDescr.cases target md isRecursiveType cto... | null | true |
Real.sinh_artanh | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x : ℝ}, x ∈ Set.Ioo (-1) 1 → Real.sinh (Real.artanh x) = x / √(1 - x ^ 2) | null | true |
MeasureTheory.IsSetSemiring.isSetRing_supClosure | Mathlib.MeasureTheory.SetSemiring | ∀ {α : Type u_1} {C : Set (Set α)}, MeasureTheory.IsSetSemiring C → MeasureTheory.IsSetRing (supClosure C) | null | true |
Std.DHashMap.Raw.Const.getD_modify_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k : α} {fallback : β} {f : β → β},
m.WF →
Std.DHashMap.Raw.Const.getD (Std.DHashMap.Raw.Const.modify m k f) k fallback =
(Option.map f (Std.DHashMap.Raw.Const.get?... | null | true |
CategoryTheory.MonoOver.congr | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(X : C) →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(e : C ≌ D) → CategoryTheory.MonoOver X ≌ CategoryTheory.MonoOver (e.functor.obj X) | An equivalence of categories `e` between `C` and `D` induces an equivalence between
`MonoOver X` and `MonoOver (e.functor.obj X)` whenever `X` is an object of `C`. | true |
PresentedGroup.closure_rels_subset_ker | Mathlib.GroupTheory.PresentedGroup | ∀ {α : Type u_1} {G : Type u_3} [inst : Group G] {f : α → G} {rels : Set (FreeGroup α)},
(∀ r ∈ rels, (FreeGroup.lift f) r = 1) → Subgroup.normalClosure rels ≤ (FreeGroup.lift f).ker | null | true |
_private.Lean.Data.Json.Printer.0.Lean.Json.CompressWorkItemKind.ctorElimType | Lean.Data.Json.Printer | {motive : Lean.Json.CompressWorkItemKind✝ → Sort u} → ℕ → Sort (max 1 u) | null | false |
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.ker_id_sub_eq_of_proj._simp_1_1 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
ULift.group.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : Group α], ULift.group = Function.Injective.group ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | null | true |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.add_point._proof_1_5 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {x : α} (u : ℕ → α),
Monotone u →
∀ (n : ℕ) (exists_N : ∃ N ≤ n, x < u N) (i : ℕ),
i + 1 < Nat.find exists_N →
(fun i => if i < Nat.find exists_N then u i else if i = Nat.find exists_N then x else u (i - 1)) i ≤
(fun i => if i < Nat.find exists_N the... | null | false |
OrderHom.curry | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} → [inst : Preorder α] → [inst_1 : Preorder β] → [inst_2 : Preorder γ] → (α × β →o γ) ≃o (α →o β →o γ) | Curry/uncurry as an order isomorphism between `α × β →o γ` and `α →o β →o γ`. | true |
Lean.Meta.Simp.State.diag | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.State → Lean.Meta.Simp.Diagnostics | null | true |
CStarModule.norm_pos | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ (A : Type u_1) {E : Type u_2} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ E] [inst_4 : SMul A E] [inst_5 : Norm E] [CStarModule A E] {x : E}, x ≠ 0 → 0 < ‖x‖ | null | true |
endVecRingEquivMatrixEnd._proof_3 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ (ι : Type u_1) [inst : Fintype ι] (A : Type u_3) [inst_1 : Semiring A] (M : Type u_2) [inst_2 : AddCommMonoid M]
[inst_3 : Module A M] (m : Matrix ι ι (Module.End A M)) (x y : ι → M),
(fun i => ∑ j, (m i j) ((x + y) j)) = (fun i => ∑ j, (m i j) (x j)) + fun i => ∑ j, (m i j) (y j) | null | false |
RingHom.prodMap | Mathlib.Algebra.Ring.Prod | {R : Type u_1} →
{R' : Type u_2} →
{S : Type u_3} →
{S' : Type u_4} →
[inst : NonAssocSemiring R] →
[inst_1 : NonAssocSemiring S] →
[inst_2 : NonAssocSemiring R'] →
[inst_3 : NonAssocSemiring S'] → (R →+* R') → (S →+* S') → R × S →+* R' × S' | `Prod.map` as a `RingHom`. | true |
natCast_zsmul._f | Mathlib.Algebra.Group.DivInvMonoid | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a : G) (x : ℕ) (f : Nat.below x), ↑x • a = x • a | null | false |
ContinuousLinearMap.inverse_of_not_isInvertible | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Invertible | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace M₂]
[inst_2 : Semiring R] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₂] {f : M →L[R] M₂}, ¬f.IsInvertible → f.inverse = 0 | By definition, if `f` is not invertible then `inverse f = 0`. | true |
SummationFilter.mk.noConfusion | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | {β : Type u_4} →
{P : Sort u} →
{filter filter' : Filter (Finset β)} → { filter := filter } = { filter := filter' } → (filter ≍ filter' → P) → P | null | false |
HomotopicalAlgebra.FibrantBrownFactorization.mk.noConfusion | Mathlib.AlgebraicTopology.ModelCategory.BrownLemma | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : HomotopicalAlgebra.ModelCategory C} →
{X Y : C} →
{f : X ⟶ Y} →
{P : Sort u} →
{toMapFactorizationData :
(HomotopicalAlgebra.trivialCofibrations C).MapFactorizationData (HomotopicalAlgebr... | null | false |
groupHomology.lsingle_comp_chainsMap_f_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (n : ℕ) (x : Fin n → G) {Z : ModuleCat k}
(h : ↧((Fin n → H) →₀ ↑B) ⟶ Z),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (Finsupp.lsingle x))
(... | null | true |
MeasureTheory.measure_iInter_of_ae_antitone | Mathlib.MeasureTheory.Measure.Continuity | ∀ {α : Type u_1} {ι : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : ι → Set α}
[inst : Preorder ι] [IsDirectedOrder ι] [Filter.atTop.IsCountablyGenerated],
(∀ᵐ (ω : α) ∂μ, Antitone fun x => ω ∈ s x) →
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) → (∃ i, μ (s i) ≠ ⊤) → μ (⋂ i, s i)... | Continuity from above (a.e. version):
the measure of the intersection of a family of sets that is almost everywhere antitone
is equal to the infimum of the measures. | true |
Int.gcd_mul_right_add_right | Init.Data.Int.Gcd | ∀ (m n k : ℤ), m.gcd (k * m + n) = m.gcd n | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey_modify._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Lean.Meta.EqnsExtState.recOn | Lean.Meta.Eqns | {motive : Lean.Meta.EqnsExtState → Sort u} →
(t : Lean.Meta.EqnsExtState) → ((mapInv : Lean.PHashMap Lean.Name Lean.Name) → motive { mapInv := mapInv }) → motive t | null | false |
Irrational.intCast_sub | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, Irrational x → ∀ (m : ℤ), Irrational (↑m - x) | null | true |
Complex.cos_surjective | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Function.Surjective Complex.cos | null | true |
Subgroup.subgroupOf_map_subtype | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), Subgroup.map K.subtype (H.subgroupOf K) = H ⊓ K | null | true |
CategoryTheory.Limits.ImageMap.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{f g : CategoryTheory.Arrow C} →
[inst_1 : CategoryTheory.Limits.HasImage f.hom] →
[inst_2 : CategoryTheory.Limits.HasImage g.hom] →
{sq : f ⟶ g} →
{motive : CategoryTheory.Limits.ImageMap sq → Sort u_1} →
... | null | false |
_private.Mathlib.Algebra.Group.ModEq.0.AddCommGroup.modEq_nsmul_cases._simp_1_1 | Mathlib.Algebra.Group.ModEq | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b c : G}, (a ≡ c + b [PMOD p]) = (a - b ≡ c [PMOD p]) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.Real.rpow_eq_const_mul_integral_rpowIntegrand₁₂._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | (1 + 1).AtLeastTwo | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.prod_Icc_div._proof_1_1 | Mathlib.Algebra.BigOperators.Intervals | ∀ {m n : ℕ}, m ≤ n → ¬m ≤ n + 1 → False | null | false |
_private.Init.Data.Fin.Fold.0.Fin.foldlM.loop | Init.Data.Fin.Fold | {m : Type u_1 → Type u_2} → {α : Type u_1} → [Monad m] → (n : ℕ) → (α → Fin n → m α) → α → ℕ → m α | Inner loop for `Fin.foldlM`.
```
Fin.foldlM.loop n f xᵢ i = do
let xᵢ₊₁ ← f xᵢ i
...
let xₙ ← f xₙ₋₁ (n-1)
pure xₙ
```
| true |
Computability.Γ'.bit.injEq | Mathlib.Computability.Encoding | ∀ (b b_1 : Bool), (Computability.Γ'.bit b = Computability.Γ'.bit b_1) = (b = b_1) | null | true |
CategoryTheory.ShortComplex.Hom.id_τ₂ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.Hom.id S).τ₂ = CategoryTheory.CategoryStruct.id S.X₂ | null | true |
Monotone.csInf_image_le | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice β] [inst_1 : Preorder α] {f : α → β},
Monotone f → ∀ {s : Set α} {c : α}, c ∈ s → BddBelow s → sInf (f '' s) ≤ f c | null | true |
Lean.Macro.Context.rec | Init.Prelude | {motive : Lean.Macro.Context → Sort u} →
((methods : Lean.Macro.MethodsRef) →
(quotContext : Lean.Name) →
(currMacroScope : Lean.MacroScope) →
(currRecDepth maxRecDepth : ℕ) →
(ref : Lean.Syntax) →
motive
{ methods := methods, quotContext := quotContex... | null | false |
instWeakPseudoEMetricSpaceWithTop._proof_2 | Mathlib.Topology.EMetricSpace.Weak | ∀ {α : Type u_1} [t : TopologicalSpace α] [m : WeakPseudoEMetricSpace α] (x y : WithTop α), edist x y = edist y x | null | false |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.card_veblen_le._simp_1_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
Nat.Internal.Linear.Expr.denote_toPoly_go | Init.Data.Nat.Internal.Linear | ∀ {k : ℕ} {p : Nat.Internal.Linear.Poly} (ctx : Nat.Internal.Linear.Context) (e : Nat.Internal.Linear.Expr),
Nat.Internal.Linear.Poly.denote ctx (Nat.Internal.Linear.Expr.toPoly.go k e p) =
k * Nat.Internal.Linear.Expr.denote ctx e + Nat.Internal.Linear.Poly.denote ctx p | null | true |
Lake.BuildTrace.recOn | Lake.Build.Trace | {motive_1 : Lake.BuildTrace → Sort u} →
{motive_2 : Array Lake.BuildTrace → Sort u} →
{motive_3 : List Lake.BuildTrace → Sort u} →
(t : Lake.BuildTrace) →
((caption : String) →
(inputs : Array Lake.BuildTrace) →
(hash : Lake.Hash) →
(mtime : Lake.MTime) →
... | null | false |
Std.Slice.Internal.ByteSliceData._sizeOf_inst | Std.Data.ByteSlice | SizeOf Std.Slice.Internal.ByteSliceData | null | false |
TopCat.GlueData.ofOpenSubsets_toGlueData_t | Mathlib.Topology.Gluing | ∀ {α : Type u} [inst : TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α)
(i j :
{ J := J, U := fun i => (TopologicalSpace.Opens.toTopCat ↧α).obj (U i),
V := fun x j => (TopologicalSpace.Opens.map (U x).inclusion').obj (U j),
t := fun i j => TopCat.ofHom { toFun := fun x => ⟨⟨↑↑x,... | null | true |
multilinearCurryRightEquiv._proof_1 | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ (R : Type u_1) {n : ℕ} (M : Fin n.succ → Type u_3) (M₂ : Type u_2) [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂], SMulCommClass R R (M (Fin.last n) →ₗ[R] M₂) | null | false |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.Tendsto.atBot_mul_const_of_neg'._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atBot = Filter.Tendsto f l Filter.atTop | null | false |
Prod.fst_sSup | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SupSet α] [inst_1 : SupSet β] (s : Set (α × β)),
(sSup s).1 = sSup (Prod.fst '' s) | null | true |
Representation.invtSubmodule.top_mem | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V), ⊤ ∈ ρ.invtSubmodule | null | true |
_private.Mathlib.RingTheory.Polynomial.ScaleRoots.0.Polynomial.mul_scaleRoots._simp_1_2 | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doNested._regBuiltin.Lean.Parser.Term.doNested.parenthesizer_11 | Lean.Parser.Do | IO Unit | null | false |
max_apply_eq_max | Init.Data.Order.MinMaxOn | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [DecidableLE α] [inst_2 : Max α] [Std.LawfulOrderLeftLeaningMax α]
[inst_4 : Max β] [inst_5 : LE β] [DecidableLE β] [Std.LawfulOrderLeftLeaningMax β] (f : α → β) {a b : α},
(f b ≤ f a ↔ b ≤ a) → f a ⊔ f b = f (a ⊔ b) | null | true |
Lean.Meta.Sym.Arith.ClassifyResult.nonCommSemiring.noConfusion | Lean.Meta.Sym.Arith.Types | {P : Sort u} →
{id id' : ℕ} →
Lean.Meta.Sym.Arith.ClassifyResult.nonCommSemiring id = Lean.Meta.Sym.Arith.ClassifyResult.nonCommSemiring id' →
(id = id' → P) → P | null | false |
codiscrete_eq_cofinite | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] [CompactSpace X], Filter.codiscrete X = Filter.cofinite | null | true |
Polynomial.adjSylvester_comp_sylveserMap | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {m n : ℕ} {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n),
f.adjSylvester g ∘ₗ f.sylvesterMap g hf hg = f.resultant g m n • LinearMap.id | **Alias** of `Polynomial.adjSylvester_comp_sylvesterMap`. | true |
Equiv.instTrans | Mathlib.Logic.Equiv.Defs | Trans Equiv Equiv Equiv | null | true |
_private.Mathlib.Topology.MetricSpace.GromovHausdorff.0.GromovHausdorff.IsometryRel | Mathlib.Topology.MetricSpace.GromovHausdorff | TopologicalSpace.NonemptyCompacts ↥(lp (fun n => ℝ) ⊤) → TopologicalSpace.NonemptyCompacts ↥(lp (fun n => ℝ) ⊤) → Prop | Equivalence relation identifying two nonempty compact sets which are isometric | true |
CategoryTheory.Subobject.exists_mk_eq_imageSubobject | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasImages C] {A : C}
(g : A ⟶ X) [inst_2 : CategoryTheory.Mono g] (f : X ⟶ Y),
(CategoryTheory.Subobject.exists f).obj (CategoryTheory.Subobject.mk g) =
CategoryTheory.Limits.imageSubobject (CategoryTheory.Categor... | null | true |
Lean.Server.Ilean.ctorIdx | Lean.Server.References | Lean.Server.Ilean → ℕ | null | false |
CategoryTheory.Localization.strictUniversalPropertyFixedTargetId_lift | Mathlib.CategoryTheory.Localization.Predicate | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) (E : Type u_3)
[inst_1 : CategoryTheory.Category.{v_3, u_3} E] (hW : W ≤ CategoryTheory.MorphismProperty.isomorphisms C)
(F : CategoryTheory.Functor C E) (x : W.IsInvertedBy F),
(CategoryTheory.Localization.stri... | null | true |
MeasureTheory.integrable_add_of_disjoint | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
{f g : α → E},
Disjoint (Function.support f) (Function.support g) →
MeasureTheory.StronglyMeasurable f →
MeasureTheory.StronglyMeasurable g →
(MeasureTheory.Integrable (f + g) μ ↔ M... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.