name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Data.ZMod.Basic.0.ZMod.coprime_mod_iff_coprime._proof_1_1 | Mathlib.Data.ZMod.Basic | ∀ (m n : ℕ), (m % n).gcd n = m.gcd n → ((m % n).gcd n = 1 ↔ m.gcd n = 1) | false |
Mathlib.Tactic.Ring.pow_prod_atom | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_1} [inst : CommSemiring R] (a : R) (b : ℕ), a ^ b = (a + 0) ^ b * Nat.rawCast 1 | true |
Lean.Compiler.LCNF.SpecState | Lean.Compiler.LCNF.SpecInfo | Type | true |
_private.Init.Data.UInt.Lemmas.0.UInt64.toUInt16_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
KaehlerDifferential.submodule_span_range_eq_ideal | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Submodule.span S (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) =
Submodule.restrictScalars S (KaehlerDifferential.ideal R S) | true |
CategoryTheory.Functor.mapAddMonFunctor._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(D : Type u_2) [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.LaxMonoidalFunctor C D} (x : X ⟶ Y) (x_1 : Y ⟶ Z) (A : CategoryTheory.AddMon C),
CategoryTheory.CategoryStruct.comp CategoryTheory.AddMonObj.add
((CategoryTheory.CategoryStruct.comp x x_1).hom.app A.X) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom ((CategoryTheory.CategoryStruct.comp x x_1).hom.app A.X)
((CategoryTheory.CategoryStruct.comp x x_1).hom.app A.X))
CategoryTheory.AddMonObj.add | false |
TensorAlgebra.equivFreeAlgebra._proof_4 | Mathlib.LinearAlgebra.TensorAlgebra.Basis | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
Nat.nth_le_of_strictMonoOn_of_mapsTo | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (f : ℕ → ℕ),
Set.MapsTo f {n | ∀ (hf : (setOf p).Finite), n < hf.toFinset.card} (setOf p) →
StrictMonoOn f {n | ∀ (hf : (setOf p).Finite), n < hf.toFinset.card} → ∀ {n : ℕ}, Nat.nth p n ≤ f n | true |
FreeAlgebra.Rel.add_assoc | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] {a b c : FreeAlgebra.Pre R X},
FreeAlgebra.Rel R X (a + b + c) (a + (b + c)) | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry!._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → [Inhabited (α × β)] → (Std.DTreeMap.Internal.Impl α fun x => β) → α × β | false |
Lean.Grind.AC.Seq.concat_k.eq_1 | Init.Grind.AC | ∀ (s₁ : Lean.Grind.AC.Seq),
s₁.concat_k =
Lean.Grind.AC.Seq.rec (motive := fun x => Lean.Grind.AC.Seq → Lean.Grind.AC.Seq)
(fun x s₂ => Lean.Grind.AC.Seq.cons x s₂) (fun x x_1 ih s₂ => Lean.Grind.AC.Seq.cons x (ih s₂)) s₁ | true |
_private.Lean.Data.EditDistance.0.Lean.EditDistance.levenshtein._proof_1 | Lean.Data.EditDistance | ∀ (str2 : String), ∀ i ∈ [:(Vector.replicate (str2.length + 1) 0).size], i < str2.length + 1 | false |
AddSubmonoid.mem_map_of_mem | 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) {S : AddSubmonoid M} {x : M},
x ∈ S → f x ∈ AddSubmonoid.map f S | true |
AddMagmaCat.neg_hom_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {M N : AddMagmaCat} (e : M ≅ N) (x : ↑M),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | true |
Aesop.SafeRulesResult.succeeded.inj | Aesop.Search.Expansion | ∀ {newRapps newRapps_1 : Array Aesop.RappRef},
Aesop.SafeRulesResult.succeeded newRapps = Aesop.SafeRulesResult.succeeded newRapps_1 → newRapps = newRapps_1 | true |
one_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Monoid α] (s : Set α), 1 • s = s | true |
Lean.IR.ToIR.BuilderState.joinPoints._default | Lean.Compiler.IR.ToIR | Std.HashMap Lean.FVarId Lean.IR.JoinPointId | false |
_private.Init.Data.List.Nat.Erase.0.List.eraseIdx_set_lt._proof_1_2 | Init.Data.List.Nat.Erase | ∀ {α : Type u_1} {l : List α} {i j : ℕ} {a : α}, j < i → ∀ n < j, i - 1 = n → False | false |
ENat.sub_iInf | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_2} {f : ι → ℕ∞} {a : ℕ∞}, a - ⨅ i, f i = ⨆ i, a - f i | true |
PowerBasis.map | Mathlib.RingTheory.PowerBasis | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{S' : Type u_7} →
[inst_3 : CommRing S'] → [inst_4 : Algebra R S'] → PowerBasis R S → (S ≃ₐ[R] S') → PowerBasis R S' | true |
_private.Batteries.Data.List.Basic.0.List.forall₂_cons.match_1_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {a : α} {b : β} {l₁ : List α} {l₂ : List β}
(motive : List.Forall₂ R (a :: l₁) (b :: l₂) → Prop) (x : List.Forall₂ R (a :: l₁) (b :: l₂)),
(∀ (h : R a b) (tail : List.Forall₂ R l₁ l₂), motive ⋯) → motive x | false |
Lean.Server.RequestError.rec | Lean.Server.Requests | {motive : Lean.Server.RequestError → Sort u} →
((code : Lean.JsonRpc.ErrorCode) → (message : String) → motive { code := code, message := message }) →
(t : Lean.Server.RequestError) → motive t | false |
NonemptyInterval.toDualProd_injective | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : LE α], Function.Injective NonemptyInterval.toDualProd | true |
_private.Batteries.Data.List.Lemmas.0.List.mem_findIdxs_iff_getElem_sub_pos._proof_1_7 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} (head : α) (tail : List α) {s : ℕ},
-1 * ↑i + ↑s ≤ 0 → i - s + 1 ≤ (head :: tail).length → -1 * ↑i + ↑s + 1 ≤ 0 → i - (s + 1) < tail.length | false |
CategoryTheory.Equivalence.symmEquivInverse_obj_functor | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (X : (D ≌ C)ᵒᵖ),
((CategoryTheory.Equivalence.symmEquivInverse C D).obj X).functor = (Opposite.unop X).inverse | true |
_private.Mathlib.Data.Finset.SymmDiff.0.Finset.mem_symmDiff._simp_1_1 | Mathlib.Data.Finset.SymmDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | false |
Std.DHashMap.Raw.Const.all_keys | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulHashable α]
[EquivBEq α] {p : α → Bool}, m.WF → m.keys.all p = m.all fun a x => p a | true |
Int.fmod_fmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a.fmod b).fmod b = a.fmod b | true |
CategoryTheory.Presieve.FamilyOfElements.isCompatible_map_smul_aux | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ R : CategoryTheory.Functor Cᵒᵖ RingCat} (α : R₀ ⟶ R) [CategoryTheory.Presheaf.IsLocallyInjective J α]
{M₀ : PresheafOfModules R₀} {A : CategoryTheory.Functor Cᵒᵖ AddCommGrpCat} (φ : M₀.presheaf ⟶ A)
[CategoryTheory.Presheaf.IsLocallyInjective J φ],
CategoryTheory.Presheaf.IsSeparated J A →
∀ {X : C} (r : ↑(R.obj (Opposite.op X))) (m : ↑(A.obj (Opposite.op X))) {Y Z : C} (f : Y ⟶ X) (g : Z ⟶ Y)
(r₀ : ↑(R₀.obj (Opposite.op Y))) (r₀' : ↑(R₀.obj (Opposite.op Z))) (m₀ : ↑(M₀.obj (Opposite.op Y)))
(m₀' : ↑(M₀.obj (Opposite.op Z))),
(CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op Y))) r₀ =
(CategoryTheory.ConcreteCategory.hom (R.map f.op)) r →
(CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op Z))) r₀' =
(CategoryTheory.ConcreteCategory.hom (R.map (CategoryTheory.CategoryStruct.comp f.op g.op))) r →
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Y))) m₀ =
(CategoryTheory.ConcreteCategory.hom (A.map f.op)) m →
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z))) m₀' =
(CategoryTheory.ConcreteCategory.hom (A.map (CategoryTheory.CategoryStruct.comp f.op g.op))) m →
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z)))
((CategoryTheory.ConcreteCategory.hom (M₀.map g.op)) (r₀ • m₀)) =
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z))) (r₀' • m₀') | true |
CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (self : F.StrongTrans G) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (self.naturality (CategoryTheory.CategoryStruct.comp f g)).hom
(CategoryTheory.Bicategory.whiskerLeft (self.app a) (G.mapComp f g).hom) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g).hom (self.app c))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (F.map g) (self.app c)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (self.naturality g).hom)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (self.app b) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (self.naturality f).hom (G.map g))
(CategoryTheory.Bicategory.associator (self.app a) (G.map f) (G.map g)).hom)))) | true |
CategoryTheory.ShortComplex.Splitting.ofIsIsoOfIsZero._proof_4 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hf : CategoryTheory.IsIso S.f),
CategoryTheory.CategoryStruct.comp (CategoryTheory.inv S.f) S.f + CategoryTheory.CategoryStruct.comp S.g 0 =
CategoryTheory.CategoryStruct.id S.X₂ | false |
_private.Lean.Compiler.LCNF.StructProjCases.0.Lean.Compiler.LCNF.StructProjCases.findStructCtorInfo?._sparseCasesOn_9 | Lean.Compiler.LCNF.StructProjCases | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.MorphismProperty.Comma.Hom.ext' | 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} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory.MorphismProperty A} {W : CategoryTheory.MorphismProperty B} [inst_3 : Q.IsMultiplicative]
[inst_4 : W.IsMultiplicative] {X Y : CategoryTheory.MorphismProperty.Comma L R P Q W} {f g : X ⟶ Y},
CategoryTheory.MorphismProperty.Comma.Hom.hom f = CategoryTheory.MorphismProperty.Comma.Hom.hom g → f = g | true |
Finset.filter_le_eq_Ici | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] {a : α} [inst_2 : Fintype α]
[inst_3 : DecidablePred fun x => a ≤ x], {x | a ≤ x} = Finset.Ici a | true |
SzemerediRegularity.stepBound_mono | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | Monotone SzemerediRegularity.stepBound | true |
contDiff_id | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : WithTop ℕ∞}, ContDiff 𝕜 n id | true |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Approximations.0.GenContFract.fib_le_of_contsAux_b._proof_1_1 | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ (n : ℕ), ¬n + 2 ≤ 1 | false |
Std.DTreeMap.getKey!_eq_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α] {k : α}, k ∈ t → t.getKey! k = k | true |
Subring.copy._proof_4 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u_1} [inst : NonAssocRing R] (S : Subring R) (s : Set R) (hs : s = ↑S), 0 ∈ (S.copy s hs).carrier | false |
HNNExtension.toSubgroup_neg_one | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] (A B : Subgroup G), HNNExtension.toSubgroup A B (-1) = B | true |
_private.Mathlib.MeasureTheory.Measure.Tight.0.MeasureTheory.exists_measure_iUnion_gt_of_isCompact_closure._simp_1_12 | Mathlib.MeasureTheory.Measure.Tight | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_2} [inst_1 : Preorder ι] [Filter.atTop.IsCountablyGenerated]
{μ : MeasureTheory.ProbabilityMeasure Ω} {f : ι → Set Ω},
Filter.Tendsto (fun i => μ (Set.accumulate f i)) Filter.atTop (nhds (μ (⋃ i, f i))) = True | false |
ZMod.val_neg_of_ne_zero | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} [nz : NeZero n] (a : ZMod n) [na : NeZero a], (-a).val = n - a.val | true |
String.ofList_eq_empty_iff | Init.Data.String.Basic | ∀ {l : List Char}, String.ofList l = "" ↔ l = [] | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Valid.prevn.match_1_3 | Batteries.Data.String.Lemmas | ∀ (x : Substring.Raw) (motive : (∃ l m r, Substring.Raw.ValidFor l m r x) → Prop)
(x_1 : ∃ l m r, Substring.Raw.ValidFor l m r x),
(∀ (l m r : List Char) (h : Substring.Raw.ValidFor l m r x), motive ⋯) → motive x_1 | false |
Module.End.instDivisionRing._proof_12 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : Module.End R M),
Semiring.npow 0 x = 1 | false |
CompleteDistribLattice.toSDiff | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} → [self : CompleteDistribLattice α] → SDiff α | true |
CategoryTheory.Limits.IsLimit.whiskerEquivalence | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} K] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{s : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit s →
(e : K ≌ J) → CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Cone.whisker e.functor s) | true |
Lean.Meta.Grind.AC.EqCnstrProof.core.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (a b : Lean.Expr) (ea eb : Lean.Grind.AC.Expr) (a_1 b_1 : Lean.Expr) (ea_1 eb_1 : Lean.Grind.AC.Expr),
(Lean.Meta.Grind.AC.EqCnstrProof.core a b ea eb = Lean.Meta.Grind.AC.EqCnstrProof.core a_1 b_1 ea_1 eb_1) =
(a = a_1 ∧ b = b_1 ∧ ea = ea_1 ∧ eb = eb_1) | true |
instFintypeAddEquivInt._proof_2 | Mathlib.GroupTheory.ArchimedeanDensely | AddEquiv.neg ℤ ∉ {AddEquiv.refl ℤ} | false |
ProperSpace.mk._flat_ctor | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α], (∀ (x : α) (r : ℝ), IsCompact (Metric.closedBall x r)) → ProperSpace α | false |
isRelLowerSet_self._simp_1 | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {s : Set α} [inst : LE α], (IsRelLowerSet s fun x => x ∈ s) = True | false |
Equiv.commSemigroup.eq_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : CommSemigroup β],
e.commSemigroup = Function.Injective.commSemigroup ⇑e ⋯ ⋯ | true |
tsum_eq_sum' | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [L.LeAtTop] {s : Finset β}, Function.support f ⊆ ↑s → ∑'[L] (b : β), f b = ∑ b ∈ s, f b | true |
AlgebraicGeometry.Scheme.germToFunctionField._proof_1 | Mathlib.AlgebraicGeometry.FunctionField | ∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens) [h : Nonempty ↥↑U], (Set.univ ∩ ↑U).Nonempty | false |
Finset.Nonempty.norm_prod_le_sup'_norm | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} {ι : Type u_2} [inst : SeminormedCommGroup M] [IsUltrametricDist M] {s : Finset ι} (hs : s.Nonempty)
(f : ι → M), ‖∏ i ∈ s, f i‖ ≤ s.sup' hs fun x => ‖f x‖ | true |
Prefunctor.IsCovering.comp | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V) {W : Type u_3} [inst_2 : Quiver W]
(ψ : V ⥤q W), φ.IsCovering → ψ.IsCovering → (φ ⋙q ψ).IsCovering | true |
Int.existsUnique_equiv | Mathlib.Data.Int.ModEq | ∀ (a : ℤ) {b : ℤ}, 0 < b → ∃ z, 0 ≤ z ∧ z < b ∧ z ≡ a [ZMOD b] | true |
padicNormE._proof_4 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p]), 0 ≤ Quotient.lift PadicSeq.norm ⋯ q | false |
List.head?_range' | Init.Data.List.Range | ∀ {s n : ℕ}, (List.range' s n).head? = if n = 0 then none else some s | true |
RCLike.nnnorm_nsmul | Mathlib.Analysis.RCLike.Basic | ∀ (K : Type u_1) {E : Type u_2} [inst : RCLike K] [inst_1 : NormedAddCommGroup E] [NormedSpace K E] (n : ℕ) (x : E),
‖n • x‖₊ = n • ‖x‖₊ | true |
HomologicalComplex.mapBifunctor₁₂.ι_D₂_assoc | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_5, u_3} C₁₂] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁]
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] [inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃]
[inst_8 : CategoryTheory.Preadditive C₁₂] [inst_9 : CategoryTheory.Preadditive C₄]
(F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂))
(G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) [inst_10 : F₁₂.PreservesZeroMorphisms]
[inst_11 : ∀ (X₁ : C₁), (F₁₂.obj X₁).PreservesZeroMorphisms] [inst_12 : G.Additive]
[inst_13 : ∀ (X₁₂ : C₁₂), (G.obj X₁₂).PreservesZeroMorphisms] {ι₁ : Type u_7} {ι₂ : Type u_8} {ι₃ : Type u_9}
{ι₁₂ : Type u_10} {ι₄ : Type u_12} [inst_14 : DecidableEq ι₄] {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂}
{c₃ : ComplexShape ι₃} (K₁ : HomologicalComplex C₁ c₁) (K₂ : HomologicalComplex C₂ c₂) (K₃ : HomologicalComplex C₃ c₃)
(c₁₂ : ComplexShape ι₁₂) (c₄ : ComplexShape ι₄) [inst_15 : TotalComplexShape c₁ c₂ c₁₂]
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] [inst_17 : K₁.HasMapBifunctor K₂ F₁₂ c₁₂] [inst_18 : DecidableEq ι₁₂]
[inst_19 : (K₁.mapBifunctor K₂ F₁₂ c₁₂).HasMapBifunctor K₃ G c₄] (i₁ : ι₁) (i₂ : ι₂) (i₃ : ι₃) (j j' : ι₄)
(h : c₁.r c₂ c₃ c₁₂ c₄ (i₁, i₂, i₃) = j) [inst_20 : HomologicalComplex.HasGoodTrifunctor₁₂Obj F₁₂ G K₁ K₂ K₃ c₁₂ c₄]
{Z : C₄} (h_1 : (⋯.mapBifunctor K₃ G c₄).X j' ⟶ Z),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.mapBifunctor₁₂.ι F₁₂ G K₁ K₂ K₃ c₁₂ c₄ i₁ i₂ i₃ j h)
(CategoryTheory.CategoryStruct.comp ⋯ h_1) =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.mapBifunctor₁₂.d₂ F₁₂ G K₁ K₂ K₃ c₁₂ c₄ i₁ i₂ i₃ j') h_1 | true |
LieRinehartAlgebra.Hom.apply_lie | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_1} {A₁ : Type u_2} {L₁ : Type u_3} {A₂ : Type u_4} {L₂ : Type u_5} [inst : CommRing R]
[inst_1 : CommRing A₁] [inst_2 : LieRing L₁] [inst_3 : Module A₁ L₁] [inst_4 : LieRingModule L₁ A₁]
[inst_5 : CommRing A₂] [inst_6 : LieRing L₂] [inst_7 : Module A₂ L₂] [inst_8 : LieRingModule L₂ A₂]
[inst_9 : Algebra R A₁] [inst_10 : LieAlgebra R L₁] [inst_11 : Algebra R A₂] [inst_12 : LieAlgebra R L₂]
{σ₁₂ : A₁ →ₐ[R] A₂} (f : LieRinehartAlgebra.Hom σ₁₂ L₁ L₂) (a : A₁) (x : L₁), σ₁₂ ⁅x, a⁆ = ⁅f.toLieHom x, σ₁₂ a⁆ | true |
Batteries.UnionFind.FindAux.mk.congr_simp | Batteries.Data.UnionFind.Basic | ∀ {n : ℕ} (s s_1 : Array Batteries.UFNode) (e_s : s = s_1) (root root_1 : Fin n),
root = root_1 →
∀ (size_eq : s.size = n), { s := s, root := root, size_eq := size_eq } = { s := s_1, root := root_1, size_eq := ⋯ } | true |
UniformOnFun.hasBasis_uniformity_of_basis_aux₁ | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ (α : Type u_1) (β : Type u_2) {ι : Type u_4} [inst : UniformSpace β] (𝔖 : Set (Set α)) {p : ι → Prop}
{s : ι → Set (β × β)},
(uniformity β).HasBasis p s →
∀ (S : Set α), (uniformity (UniformOnFun α β 𝔖)).HasBasis p fun i => UniformOnFun.gen 𝔖 S (s i) | true |
Set.mem_nsmul._simp_1 | Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | ∀ {α : Type u_1} [inst : AddMonoid α] {s : Set α} {a : α} {n : ℕ},
(a ∈ n • s) = ∃ f, (List.ofFn fun i => ↑(f i)).sum = a | false |
_private.Mathlib.Topology.DerivedSet.0.isClosed_derivedSet._simp_1_1 | Mathlib.Topology.DerivedSet | ∀ {X : Type u_1} [inst : TopologicalSpace X] (A : Set X), (derivedSet A ⊆ A) = IsClosed A | false |
Complement.rec | Init.Prelude | {α : Type u} →
{motive : Complement α → Sort u_1} →
((complement : α → α) → motive { complement := complement }) → (t : Complement α) → motive t | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.fold.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} (f : δ → (a : α) → β a → δ) (init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.fold f init b = (Std.DHashMap.Raw.foldM (fun x1 x2 x3 => pure (f x1 x2 x3)) init b).run | true |
CategoryTheory.Limits.Sigma.π | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
{β : Type w} →
[DecidableEq β] → (f : β → C) → [inst_3 : CategoryTheory.Limits.HasCoproduct f] → (b : β) → ∐ f ⟶ f b | true |
LowerSet.Iic_sup_erase | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {a : α},
a ∈ s → (∀ b ∈ s, a ≤ b → b = a) → LowerSet.Iic a ⊔ s.erase a = s | true |
Mathlib.Tactic.BicategoryCoherence.LiftHom₂.casesOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f g : a ⟶ b} →
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] →
[inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g] →
{η : f ⟶ g} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom₂ η → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom₂ η) →
((lift :
Mathlib.Tactic.BicategoryCoherence.LiftHom.lift f ⟶
Mathlib.Tactic.BicategoryCoherence.LiftHom.lift g) →
motive { lift := lift }) →
motive t | false |
instIsTransOfIsWellOrder | Mathlib.Order.RelClasses | ∀ {α : Type u} (r : α → α → Prop) [IsWellOrder α r], IsTrans α r | true |
Path.add_apply | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : Add X] [inst_2 : ContinuousAdd X] {a₁ b₁ a₂ b₂ : X}
(γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) (a : ↑unitInterval), (γ₁.add γ₂) a = γ₁ a + γ₂ a | true |
QuadraticAlgebra.instMul | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} → {a b : R} → [Mul R] → [Add R] → Mul (QuadraticAlgebra R a b) | true |
AddConstEquiv._sizeOf_inst | Mathlib.Algebra.AddConstMap.Equiv | (G : Type u_1) →
(H : Type u_2) →
{inst : Add G} → {inst_1 : Add H} → (a : G) → (b : H) → [SizeOf G] → [SizeOf H] → SizeOf (AddConstEquiv G H a b) | false |
MeasureTheory.uniformIntegrable_average | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p : ENNReal} {E : Type u_4}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
1 ≤ p →
∀ {f : ℕ → α → E},
MeasureTheory.UniformIntegrable f p μ →
MeasureTheory.UniformIntegrable (fun n => (↑n)⁻¹ • ∑ i ∈ Finset.range n, f i) p μ | true |
MonoidHom.mker_inr | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], MonoidHom.mker (MonoidHom.inr M N) = ⊥ | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.saddOverflow_eq._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q], (decide p && decide q) = decide (p ∧ q) | false |
PFunctor.Approx.AllAgree | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → ((n : ℕ) → PFunctor.Approx.CofixA F n) → Prop | true |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpConfig.match_1 | Lean.Elab.Tactic.Simp | (motive : Lean.Elab.Tactic.SimpKind → Sort u_1) →
(kind : Lean.Elab.Tactic.SimpKind) →
(Unit → motive Lean.Elab.Tactic.SimpKind.simp) →
(Unit → motive Lean.Elab.Tactic.SimpKind.simpAll) → (Unit → motive Lean.Elab.Tactic.SimpKind.dsimp) → motive kind | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage.0.circleAverage_log_norm_sub_const₂._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | false |
CategoryTheory.Functor.instIsEquivalenceOppositeOp | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [F.IsEquivalence], F.op.IsEquivalence | true |
Std.Sat.AIG.relabel | Std.Sat.AIG.Relabel | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{β : Type} → [inst_2 : Hashable β] → [inst_3 : DecidableEq β] → (α → β) → Std.Sat.AIG α → Std.Sat.AIG β | true |
CoalgCat.instMonoidalCategoryStruct._proof_1 | Mathlib.Algebra.Category.CoalgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : CoalgCat R), IsScalarTower R R ↑X.toModuleCat | false |
Lean.Server.Watchdog.RequestQueueMap.rec | Lean.Server.Watchdog | {motive : Lean.Server.Watchdog.RequestQueueMap → Sort u} →
((i : ℕ) →
(reqs : Std.TreeMap Lean.JsonRpc.RequestID (ℕ × Lean.JsonRpc.Request Lean.Json) compare) →
(queue : Std.TreeMap ℕ (Lean.JsonRpc.RequestID × Lean.JsonRpc.Request Lean.Json) compare) →
motive { i := i, reqs := reqs, queue := queue }) →
(t : Lean.Server.Watchdog.RequestQueueMap) → motive t | false |
HomotopicalAlgebra.fibrations_eq_unop | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C],
HomotopicalAlgebra.fibrations C = (HomotopicalAlgebra.cofibrations Cᵒᵖ).unop | true |
isEmpty_fintype._simp_1 | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_4}, IsEmpty (Fintype α) = Infinite α | false |
Std.DTreeMap.Internal.Impl.link2._proof_19 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l r : Std.DTreeMap.Internal.Impl α β) (szl : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner szl k' v' l' r').Balanced →
l = Std.DTreeMap.Internal.Impl.inner szl k' v' l' r' →
∀ (szr : ℕ) (k'' : α) (v'' : β k'') (l'' r'' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner szr k'' v'' l'' r'').Balanced →
r = Std.DTreeMap.Internal.Impl.inner szr k'' v'' l'' r'' → l''.Balanced | false |
Homotopy.ext | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} {inst : CategoryTheory.Category.{v, u} V} {inst_1 : CategoryTheory.Preadditive V}
{c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} {x y : Homotopy f g}, x.hom = y.hom → x = y | true |
ContinuousLinearMap.cont._autoParam | Mathlib.Topology.Algebra.Module.LinearMap | Lean.Syntax | false |
_private.Lean.Data.Json.Printer.0.Lean.Json.needEscape.go._proof_3 | Lean.Data.Json.Printer | ∀ (s : String), ∀ i < s.utf8ByteSize, InvImage (fun x1 x2 => x1 < x2) (fun x => s.utf8ByteSize - x) (i + 1) i | false |
Lean.Elab.ComputedFields.Context.compFieldVars | Lean.Elab.ComputedFields | Lean.Elab.ComputedFields.Context → Array Lean.Expr | true |
WithTop.instOrderedSub | Mathlib.Algebra.Order.Sub.WithTop | ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α] [inst_2 : OrderBot α] [inst_3 : Sub α] [OrderedSub α],
OrderedSub (WithTop α) | true |
CoalgCat.Hom.casesOn | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} →
[inst : CommRing R] →
{V W : CoalgCat R} →
{motive : V.Hom W → Sort u_1} →
(t : V.Hom W) →
((toCoalgHom' : ↑V.toModuleCat →ₗc[R] ↑W.toModuleCat) → motive { toCoalgHom' := toCoalgHom' }) → motive t | false |
AddSemigroupIdeal.coe_closure' | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : AddMonoid M] {s : Set M}, ↑(AddSemigroupIdeal.closure s) = Set.univ + s | true |
zpow_natCast | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ ↑n = a ^ n | true |
SimplicialObject.Split.nondegComplexFunctor_map_f | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : SimplicialObject.Split C} (Φ : S₁ ⟶ S₂) (n : ℕ),
(SimplicialObject.Split.nondegComplexFunctor.map Φ).f n = Φ.f n | true |
Lean.Meta.TransparencyMode.reducible | Init.MetaTypes | Lean.Meta.TransparencyMode | true |
intervalIntegral.integral_mono_on_of_le_Ioo | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f g : ℝ → ℝ} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
a ≤ b →
IntervalIntegrable f μ a b →
IntervalIntegrable g μ a b →
∀ [MeasureTheory.NoAtoms μ],
(∀ x ∈ Set.Ioo a b, f x ≤ g x) → ∫ (u : ℝ) in a..b, f u ∂μ ≤ ∫ (u : ℝ) in a..b, g u ∂μ | true |
CategoryTheory.locallyDiscreteBicategory._proof_17 | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {a b c d : CategoryTheory.LocallyDiscrete C}
{f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.eqToHom ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToIso ⋯).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (CategoryTheory.eqToIso ⋯).hom) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.