name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow_covBySMul_sq_inter_sq._simp_1_10 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
CommRingCat.Colimits.Prequotient.noConfusion | Mathlib.Algebra.Category.Ring.Colimits | {P : Sort u} →
{J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
{F : CategoryTheory.Functor J CommRingCat} →
{t : CommRingCat.Colimits.Prequotient F} →
{J' : Type v} →
{inst' : CategoryTheory.SmallCategory J'} →
{F' : CategoryTheory.Functor J' CommRingCat}... | null | false |
PartOrd.dual | Mathlib.Order.Category.PartOrd | CategoryTheory.Functor PartOrd PartOrd | `OrderDual` as a functor. | true |
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.pushNegBuiltin._sparseCasesOn_2 | Mathlib.Tactic.Push | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Order.Filter.Germ.Basic.0.Filter.Germ.IsConstant.match_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {β : Type u_1} {l : Filter α} (f : α → β) (motive : (∃ b, f =ᶠ[l] fun x => b) → Prop)
(x : ∃ b, f =ᶠ[l] fun x => b), (∀ (b : β) (hb : f =ᶠ[l] fun x => b), motive ⋯) → motive x | null | false |
Int.ModEq.prod_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {f : α → ℤ} {s : Finset α}, (∀ x ∈ s, f x ≡ 1 [ZMOD n]) → ∏ x ∈ s, f x ≡ 1 [ZMOD n] | null | true |
Matroid.isBasis_iff_isBasis'_subset_ground | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis I X ↔ M.IsBasis' I X ∧ X ⊆ M.E | null | true |
CategoryTheory.Adjunction.leftAdjointUniq_trans_assoc | Mathlib.CategoryTheory.Adjunction.Unique | ∀ {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 F' F'' : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G) (adj3 : F'' ⊣ G) {Z : CategoryTheory.Functor C D}
(h : F'' ⟶ Z),
CategoryTheory.Ca... | null | true |
_private.Mathlib.MeasureTheory.Integral.PeakFunction.0.tendsto_integral_comp_smul_smul_of_integrable._simp_1_3 | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c ≤ max a b) = (c ≤ a ∨ c ≤ b) | null | false |
UInt64.toNat_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt64), (-a).toNat = (UInt64.size - a.toNat) % UInt64.size | null | true |
ContinuousAffineMap.coe_const | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ (R : Type u_1) {V : Type u_2} {W : Type u_3} (P : Type u_4) {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (q : Q),
⇑(Cont... | null | true |
_private.Init.Data.Array.Sort.Lemmas.0.Subarray.mergeSort_eq_mergeSort_toArray._simp_1_1 | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, (xs = ys) = (xs.toList = ys.toList) | null | false |
Polynomial.cyclotomic.roots_eq_primitiveRoots_val | Mathlib.RingTheory.Polynomial.Cyclotomic.Roots | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [inst_1 : IsDomain R] [NeZero ↑n],
(Polynomial.cyclotomic n R).roots = (primitiveRoots n R).val | null | true |
Subtype.mk.hinj | Mathlib.Data.Subtype | ∀ {α : Sort u} {p : α → Prop} {val : α} {property : p val} {α_1 : Sort u} {p_1 : α_1 → Prop} {val_1 : α_1}
{property_1 : p_1 val_1}, α = α_1 → p ≍ p_1 → ⟨val, property⟩ ≍ ⟨val_1, property_1⟩ → α = α_1 ∧ p ≍ p_1 ∧ val ≍ val_1 | null | true |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.AnalyzeResult.maxS?._default | Mathlib.Tactic.FBinop | Option FBinopElab.SRec | null | false |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.mapGen_apply_apply_of_surjective.match_1_1 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring N] {c : RingCon M} (f : M →+* N)
{x y : M} (motive : (∃ a b, c a b ∧ f a = f x ∧ f b = f y) → Prop) (x_1 : ∃ a b, c a b ∧ f a = f x ∧ f b = f y),
(∀ (a b : M) (h₁ : c a b) (h₂ : f a = f x) (h₃ : f b = f y), motive ⋯) → motive x_1 | null | false |
_private.Lean.Elab.PreDefinition.FixedParams.0.Lean.Elab.FixedParamPerm.pickFixed.go._f | Lean.Elab.PreDefinition.FixedParams | {α : Type u_1} →
(x : List (Option ℕ × α)) → List.below (motive := fun x => Array α → Id (Array α)) x → Array α → Id (Array α) | null | false |
Module.FaithfullyFlat.iff_exact_iff_rTensor_exact | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.FaithfullyFlat R M ↔
∀ {N1 : Type (max u v)} [inst_3 : AddCommGroup N1] [inst_4 : Module R N1] {N2 : Type (max u v)}
[inst_5 : AddCommGroup N2] [inst_6 : Module R N2] {N3 : Type (max u v)} [inst_7 : AddCo... | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution.0.DiscreteConvolution.single_convolution._proof_1_1 | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} [inst : Monoid M] (x : M), (1, x) ∈ DiscreteConvolution.mulFiber x | null | false |
Complex.addCommGroup._proof_11 | Mathlib.Basic.Complex.Basic | ∀ (a b : ℂ), a + b = b + a | null | false |
KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk._proof_2 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R}, I.IsMaximal → UniqueFactorizationMonoid (Ideal (Polynomial (R ⧸ I))) | null | false |
UpperSemicontinuous.inf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} {β : Type u_5} [inst : TopologicalSpace α] [inst_1 : LinearOrder β] {f g : α → β},
UpperSemicontinuous f → UpperSemicontinuous g → UpperSemicontinuous fun x => min (f x) (g x) | null | true |
Equiv.Perm.sigmaCongrRight_refl | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : α → Type u_2}, (Equiv.Perm.sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl ((a : α) × β a) | null | true |
Aesop.GoalState.toNodeState | Aesop.Tree.Data | Aesop.GoalState → Aesop.NodeState | null | true |
UInt64.toUInt32_ofNatLT | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt64.size), (UInt64.ofNatLT n hn).toUInt32 = UInt32.ofNat n | null | true |
LocallyLipschitz.pow_end._f | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : Function.End α},
LocallyLipschitz f → ∀ (x : ℕ) (f_1 : Nat.below x), LocallyLipschitz (f ^ x) | null | false |
MeasureTheory.Measure.FiniteSpanningSetsIn.disjointed_set_eq | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(S : μ.FiniteSpanningSetsIn {s | MeasurableSet s}), S.disjointed.set = disjointed S.set | null | true |
NNReal.arith_mean_le_rpow_mean | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → NNReal),
∑ i ∈ s, w i = 1 → ∀ {p : ℝ}, 1 ≤ p → ∑ i ∈ s, w i * z i ≤ (∑ i ∈ s, w i * z i ^ p) ^ (1 / p) | Weighted generalized mean inequality, version for sums over finite sets, with `ℝ≥0`-valued
functions and real exponents. | true |
CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C))
(j : J), (CategoryTheory.CategoryStruct.comp P.p P.p).app j = P.p.app j | null | false |
String.isInt | Init.Data.String.Search | String → Bool | Checks whether the string can be interpreted as the decimal representation of an integer.
A string can be interpreted as a decimal integer if it only consists of at least one decimal digit
and optionally `-` in front. Leading `+` characters are not allowed.
Use `String.toInt?` or `String.toInt!` to convert
such a str... | true |
_private.Mathlib.Logic.Function.Defs.0.Function.prod_inj._simp_1_1 | Mathlib.Logic.Function.Defs | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
CategoryTheory.Limits.WeakLimitCone.cone | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{C : Type u_3} →
[inst_1 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J C} → CategoryTheory.Limits.WeakLimitCone F → CategoryTheory.Limits.Cone F | The cone itself | true |
ENNReal.toNNReal_zero | Mathlib.Basic.ENNReal.Basic | ENNReal.toNNReal 0 = 0 | null | true |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_13 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p q : Submodule R M},
(p = q) = ∀ (x : M), x ∈ p ↔ x ∈ q | null | false |
CategoryTheory.Under.forgetCone._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) ⦃X_1 Y : CategoryTheory.Under X⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Under X)).obj X).map f) Y.hom =
CategoryTheory.CategoryStruct.comp X_1.hom ((CategoryTheory.Under.forget X).map ... | null | false |
Aesop.PhaseSpec.safe.elim | Aesop.Builder.Basic | {motive : Aesop.PhaseSpec → Sort u} →
(t : Aesop.PhaseSpec) → t.ctorIdx = 0 → ((info : Aesop.SafeRuleInfo) → motive (Aesop.PhaseSpec.safe info)) → motive t | null | false |
CategoryTheory.MonoidalClosed.enrichedCategorySelf_id | Mathlib.CategoryTheory.Monoidal.Closed.Enrichment | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.MonoidalClosed C] (X : C), CategoryTheory.eId C X = CategoryTheory.MonoidalClosed.id X | null | true |
Std.DTreeMap.Internal.Impl.toList_map | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w}
{f : (a : α) → β a → γ a},
(Std.DTreeMap.Internal.Impl.map f t).toList = List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) t.toList | null | true |
ContinuousLinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : ... | null | true |
Aesop.LocalRuleSet.mk.noConfusion | Aesop.RuleSet | {P : Sort u} →
{toBaseRuleSet : Aesop.BaseRuleSet} →
{simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems)} →
{simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size} →
{simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs)} →
{simprocsArrayNonempty : 0 < simprocsArray.size} →
... | null | false |
Nonneg.nat_ceil_coe | Mathlib.Algebra.Order.Nonneg.Floor | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedRing α] [inst_3 : FloorSemiring α]
(a : Nonneg α), ⌈↑a⌉₊ = ⌈a⌉₊ | null | true |
Std.DTreeMap.Internal.Impl.minKey?_insert!_le_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {v : β k} {km kmi : α},
t.minKey? = some km → (Std.DTreeMap.Internal.Impl.insert! k v t).minKey?.get ⋯ = kmi → (compare kmi km).isLE = true | null | true |
Std.DTreeMap.Raw.get!_eq_default | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {a : α} [inst_1 : Inhabited (β a)], a ∉ t → t.get! a = default | null | true |
Set.inclusion_inclusion | Mathlib.Data.Set.Inclusion | ∀ {α : Type u_1} {s t u : Set α} (hst : s ⊆ t) (htu : t ⊆ u) (x : ↑s),
Set.inclusion htu (Set.inclusion hst x) = Set.inclusion ⋯ x | null | true |
Finset.isScalarTower' | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq γ] [inst_1 : DecidableEq β] [inst_2 : SMul α β]
[inst_3 : SMul α γ] [inst_4 : SMul β γ] [IsScalarTower α β γ], IsScalarTower α (Finset β) (Finset γ) | null | true |
CategoryTheory.ShortComplex.SnakeInput.L₀'_exact | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), S.L₀'.Exact | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback.0.CategoryTheory.MonoidalCategory.Limits.pushout.condition_whiskerRight._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y : C}
(f : W ⟶ X) (g : X ⟶ Y) (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight g Z) =
Category... | null | false |
Sym.coe_equivNatSumOfFintype_apply_apply | Mathlib.Data.Finsupp.Multiset | ∀ (α : Type u_1) [inst : DecidableEq α] (n : ℕ) [inst_1 : Fintype α] (s : Sym α n) (a : α),
↑((Sym.equivNatSumOfFintype α n) s) a = Multiset.count a ↑s | null | true |
Aesop.Script.STactic.ctorIdx | Aesop.Script.Tactic | Aesop.Script.STactic → ℕ | null | false |
SemiNormedGrp.explicitCokernel | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | {X Y : SemiNormedGrp} → (X ⟶ Y) → SemiNormedGrp | An explicit choice of cokernel, which has good properties with respect to the norm. | true |
Lean.Grind.Linarith.le_lt_combine_cert | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool | null | true |
AddSubsemigroup.toSubsemigroup_closure | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {A : Type u_5} [inst : Add A] (S : Set A),
AddSubsemigroup.toSubsemigroup (AddSubsemigroup.closure S) = Subsemigroup.closure (⇑Multiplicative.toAdd ⁻¹' S) | null | true |
Lean.Expr.containsFVar | Lean.Expr | Lean.Expr → Lean.FVarId → Bool | Return `true` if `e` contains the given free variable. | true |
Aesop.instToJsonPhaseName.toJson | Aesop.Rule.Name | Aesop.PhaseName → Lean.Json | null | true |
Std.PRange.UpwardEnumerable.Map.PreservesLT.casesOn | Init.Data.Range.Polymorphic.Map | {α : Type u_1} →
{β : Type u_2} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
[inst_2 : LT α] →
[inst_3 : LT β] →
{f : Std.PRange.UpwardEnumerable.Map α β} →
{motive : f.PreservesLT → Sort u} →
(t : f.Preserv... | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_466 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
FirstOrder.Language.IsFraisse.is_equiv_invariant | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)} [h : FirstOrder.Language.IsFraisse K]
{M N : CategoryTheory.Bundled L.Structure}, Nonempty (L.Equiv ↑M ↑N) → (M ∈ K ↔ N ∈ K) | null | true |
PiLp.nnnorm_single | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [hp : Fact (1 ≤ p)] [inst : Fintype ι]
[inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_2 : DecidableEq ι] (i : ι) (b : β i),
‖PiLp.single p i b‖₊ = ‖b‖₊ | null | true |
String.take_eq | Batteries.Data.String.Lemmas | ∀ (s : String) (n : ℕ), String.Legacy.take s n = String.ofList (List.take n s.toList) | null | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.getIndexToInclude? | Lean.Elab.Match | Lean.Expr → List ℕ → Lean.Elab.TermElabM (Option Lean.Expr) | Collect problematic index for the "discriminant refinement feature". This method is invoked
when we detect a type mismatch at a pattern #`idx` of some alternative. | true |
Std.DTreeMap.Internal.Impl.toListModel_insertMin | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] {k : α} {v : β k} {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced},
(Std.DTreeMap.Internal.Impl.insertMin k v t h).impl.toListModel = ⟨k, v⟩ :: t.toListModel | null | true |
Preord.inv_hom_apply | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (e : X ≅ Y) (x : ↑X),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | null | true |
ContinuousAffineMap._sizeOf_inst | Mathlib.Topology.Algebra.ContinuousAffineMap | (R : Type u_1) →
{V : Type u_2} →
{W : Type u_3} →
(P : Type u_4) →
(Q : Type u_5) →
{inst : Ring R} →
{inst_1 : AddCommGroup V} →
{inst_2 : Module R V} →
{inst_3 : TopologicalSpace P} →
{inst_4 : AddTorsor V P} →
... | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.midπ_w_f_assoc | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] [inst_3 : CategoryTheory.Mono f]
(n₀ : ℤ) [inst_4 : K.IsStrictlyGE (n₀ + 1)] [inst_5 : L.IsStrictlyGE (n₀ + 1)] (q₁ q₂ : ℕ) (hq : q₁ ... | null | true |
CategoryTheory.Presheaf.isSheaf_iff_extensiveSheaf_of_projective | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] (F : CategoryTheory.Functor Cᵒᵖ A)
[inst_2 : CategoryTheory.Preregular C] [inst_3 : CategoryTheory.FinitaryExtensive C]
[∀ (X : C), CategoryTheory.Projective X],
CategoryTheory.Presheaf.IsS... | null | true |
_private.Lean.DocString.Markdown.0.Lean.Doc.MarkdownM.State.mk._flat_ctor | Lean.DocString.Markdown | Array (String × String) → Lean.Doc.MarkdownM.State | null | false |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CompleteSpace Aᵐᵒᵖ | null | false |
CategoryTheory.Arrow.LeftHomotopy.trans._proof_1 | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{u v : CategoryTheory.Arrow V} {e f g : u ⟶ v} (h : CategoryTheory.Arrow.LeftHomotopy e f)
(k : CategoryTheory.Arrow.LeftHomotopy f g),
CategoryTheory.Arrow.Hom.left e - CategoryTheory.Arrow.Hom.left g =
Cat... | null | false |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSimpa?__1_1 | Init.Tactics | Lean.Macro | null | false |
BoundedVariationOn.stieltjesFunctionRightLim.eq_1 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α] {E : Type u_2}
[inst_3 : NormedAddCommGroup E] [inst_4 : CompleteSpace E] {f : α → E} (hf : BoundedVariationOn f Set.univ) (x₀ : α),
hf.stieltjesFunctionRightLim x₀ =
{ toFun := fun x => variationOnFromTo (Function.... | null | true |
Frm.Hom.recOn | Mathlib.Order.Category.Frm | {X Y : Frm} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : FrameHom ↑X ↑Y) → motive { hom' := hom' }) → motive t | null | false |
Polynomial.one_le_cauchyBound._simp_1 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {K : Type u_1} [inst : NormedDivisionRing K] (p : Polynomial K), (1 ≤ p.cauchyBound) = True | null | false |
FormalMultilinearSeries.ofScalars_radius_eq_inv_of_tendsto_ENNReal | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing E] [inst_2 : NormedAlgebra 𝕜 E]
(c : ℕ → 𝕜) [NormOneClass E] {r : ENNReal},
Filter.Tendsto (fun n => ENNReal.ofReal ‖c n.succ‖ / ENNReal.ofReal ‖c n‖) Filter.atTop (nhds r) →
(FormalMultilinearSeries.ofScalars E c).radiu... | This theorem combines the results of the special cases above, using `ENNReal` division to remove
the requirement that the ratio is eventually non-zero. | true |
CategoryTheory.Limits.pushout.instIsIsoCodiagonalOfEpi | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f f] [CategoryTheory.Epi f],
CategoryTheory.IsIso (CategoryTheory.Limits.pushout.codiagonal f) | null | true |
Std.ExtTreeMap.getKey!_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α}, cmp k k' = Ordering.eq → t.getKey! k = t.getKey! k' | null | true |
Algebra.QuasiFiniteAt.of_isOpen_singleton_fiber | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S] (q : PrimeSpectrum S), IsOpen {⟨q, ⋯⟩} → Algebra.QuasiFiniteAt R q.asIdeal | null | true |
Membership.noConfusionType | Init.Prelude | Sort u_1 → {α : Type u} → {γ : Type v} → Membership α γ → {α' : Type u} → {γ' : Type v} → Membership α' γ' → Sort u_1 | null | false |
LinearIsometryEquiv.instEquivLike._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_3} {E₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.prod_one_div_prime_den_coprime._simp_1_1 | Mathlib.NumberTheory.Bernoulli | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
_private.Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf.0.CategoryTheory.Precoverage.SmallConstruction.Witness.restrict | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{K : CategoryTheory.Precoverage C} →
{ι : C → Type w} →
{X Y : C} →
(X ⟶ Y) →
CategoryTheory.Precoverage.SmallConstruction.Witness✝ K ι Y →
CategoryTheory.Precoverage.SmallConstruction.Witness✝ K ι X | null | true |
HahnSeries.SummableFamily.instModule._proof_10 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_4} {R : Type u_2} {V : Type u_5} {α : Type u_3} [inst : AddCommMonoid Γ]
[inst_1 : PartialOrder Γ] [inst_2 : PartialOrder Γ'] [inst_3 : AddAction Γ Γ'] [inst_4 : IsOrderedCancelVAdd Γ Γ']
[inst_5 : Semiring R] [inst_6 : AddCommMonoid V] [inst_7 : Module R V] (x : HahnSeries Γ R)
(x_1... | null | false |
SSet.relativeCellComplexOfMono_F | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {X Y : SSet} (i : X ⟶ Y) [inst : CategoryTheory.Mono i],
(SSet.relativeCellComplexOfMono i).F = ⋯.functor.comp SSet.Subcomplex.toSSetFunctor | null | true |
CategoryTheory.ShortComplex.Homotopy.sub | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂} →
CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ →
CategoryTheory.ShortComplex.Homotopy φ₃ φ₄ → CategoryTheor... | Homotopy between morphisms of short complexes is compatible with subtraction. | true |
Batteries.CodeAction.TacticCodeActionEntry.mk.inj | Batteries.CodeAction.Attr | ∀ {declName : Lean.Name} {tacticKinds : Array Lean.Name} {declName_1 : Lean.Name} {tacticKinds_1 : Array Lean.Name},
{ declName := declName, tacticKinds := tacticKinds } = { declName := declName_1, tacticKinds := tacticKinds_1 } →
declName = declName_1 ∧ tacticKinds = tacticKinds_1 | null | true |
Bipointed.toProd | Mathlib.CategoryTheory.Category.Bipointed | (self : Bipointed) → self.X × self.X | The two points of a bipointed type, bundled together as a pair. | true |
String.Pos.Raw.offsetOfPos | Init.Data.String.Basic | String → String.Pos.Raw → ℕ | Returns the character index that corresponds to the provided position (i.e. UTF-8 byte index) in a
string.
If the position is at the end of the string, then the string's length in characters is returned. If
the position is invalid due to pointing at the middle of a UTF-8 byte sequence, then the character
index of the ... | true |
CategoryTheory.Limits.limitCompCoyonedaIsoCone._proof_2 | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor J C) (X : C),
CategoryTheory.Limits.HasLimit (F.comp (CategoryTheory.coyoneda.obj (Opposite.op X))) | null | false |
Mathlib.Tactic.IntervalCases.Methods.roundDown | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Given `a, b, b', p` where `p` proves `a ≱ b` and `b' := b-1`, prove `a ≤ b'`. | true |
_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocsExt.match_3 | Lean.Linter.MissingDocs | (motive : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler → Sort u_1) →
(x : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler) →
((n k : Lean.Name) → (h : Lean.Linter.MissingDocs.Handler) → motive (n, k, h)) → motive x | null | false |
CentroidHom.applyModule._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), f 0 = 0 | null | false |
Finset.min'_eq_sorted_zero | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {h : s.Nonempty}, s.min' h = (s.sort fun a b => a ≤ b)[0] | null | true |
Inclusion.IntervalDyadicReal.mem_Ici._inclusionExt_1 | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Basic | Inclusion.InclusionExt | null | false |
SheafOfModules.Presentation.isColimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R} (P : M.Presentation),
CategoryTheory.Categ... | null | false |
SubmodulesRingBasis.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
{B : ι → Submodule R A},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) →
(∀ (a : A) (i : ι), ∃ j, a • B j ≤ B i) → (∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)) → SubmodulesRingBasis B | null | false |
RingCon.coe_zsmul._simp_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : AddGroup R] [inst_1 : Mul R] (c : RingCon R) (z : ℤ) (x : R), z • ↑x = ↑(z • x) | null | false |
Function.update_comp_eq_of_forall_ne' | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] {α' : Sort u_1} (g : (a : α) → β a) {f : α' → α} {i : α}
(a : β i), (∀ (x : α'), f x ≠ i) → (fun j => Function.update g i a (f j)) = fun j => g (f j) | null | true |
String.Slice.Pos.get_skipWhile_char_ne | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos} {h : pos.skipWhile c ≠ s.endPos}, (pos.skipWhile c).get h ≠ c | null | true |
GenContFract.toEuler_s_zero.match_1 | Mathlib.Algebra.ContinuedFractions.Euler | {K : Type u_1} →
(motive : GenContFract.Pair K → Sort u_2) →
(x : GenContFract.Pair K) → ((a b : K) → motive { a := a, b := b }) → motive x | null | false |
Module.Finite.exists_fin_quot_equiv | Mathlib.RingTheory.Finiteness.Cardinality | ∀ (R : Type u_3) (M : Type u_4) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M],
∃ n S, Nonempty (((Fin n → R) ⧸ S) ≃ₗ[R] M) | A finite module can be realised as a quotient of `Fin n → R` (i.e. `R^n`). | true |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.crown₄.match_1_1 | Mathlib.CategoryTheory.Filtered.Basic | (motive : Fin 0 → Sort u_1) → (a : Fin 0) → motive a | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.