name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.analyticAt_relation_zero | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), AnalyticAt ℂ (PeriodPair.relation✝ L) 0 | null | true |
Measurable.fun_const_vadd | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {X : Type u_3} {α : Type u_4} [inst : MeasurableSpace X] [inst_1 : VAdd M X] {m : MeasurableSpace α}
{g : α → X} [MeasurableConstVAdd M X], Measurable g → ∀ (c : M), Measurable fun i => c +ᵥ g i | Eta-expanded form of `Measurable.const_vadd` | true |
ZeroHom.withBotMap._proof_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {M : Type u_2} {N : Type u_1} [inst : Zero M] [inst_1 : Zero N] (f : ZeroHom M N), WithBot.map (⇑f) 0 = 0 | null | false |
CategoryTheory.PreGaloisCategory.IsGalois.mk | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C] {X : C}
[toIsConnected : CategoryTheory.PreGaloisCategory.IsConnected X],
Nonempty
(CategoryTheory.Limits.IsTerminal
(CategoryTheory.Limits.colimit (CategoryTheory.SingleObj.functor CategoryTheory.Au... | null | true |
Lean.Lsp.LeanModuleQuery.mk._flat_ctor | Lean.Data.Lsp.Internal | String → Array Lean.Lsp.OpenNamespace → Lean.Lsp.LeanModuleQuery | null | false |
_private.Mathlib.NumberTheory.EulerProduct.DirichletLSeries.0.DirichletCharacter.eulerProduct_log_eq_LSeries._simp_1_3 | Mathlib.NumberTheory.EulerProduct.DirichletLSeries | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
instToStringId._aux_1 | Init.Data.ToString.Basic | {α : Type u_1} → [ToString α] → ToString (id α) | null | false |
CategoryTheory.Limits.IsColimit.fac_assoc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cocone F} (self : CategoryTheory.Limits.IsColimit t)
(s : CategoryTheory.Limits.Cocone F) (j : J) {Z : C} (h : s.pt ⟶ Z),
CategoryTheo... | The map `desc` makes the diagram with the natural transformations commute | true |
Lean.Meta.SimpTheorems.mk | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Meta.SimpTheoremTree →
Lean.Meta.SimpTheoremTree →
Lean.PHashSet Lean.Meta.Origin →
Lean.PHashSet Lean.Name →
Lean.PHashSet Lean.Meta.Origin → Lean.PHashMap Lean.Name (Array Lean.Name) → Lean.Meta.SimpTheorems | null | true |
integral_sin | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ}, ∫ (x : ℝ) in a..b, Real.sin x = Real.cos a - Real.cos b | null | true |
AlgebraicGeometry.Scheme.Cover.gluedCoverT'_fst_fst_assoc | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.I₀) {Z : AlgebraicGeometry.Scheme} (h : 𝒰.X y ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Cover.gluedCoverT' 𝒰 x y z)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pu... | null | true |
interior_closure_idem | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, interior (closure (interior (closure s))) = interior (closure s) | null | true |
Inclusion.ParamArg._sizeOf_inst | Mathlib.Tactic.Inclusion.ExtensionAPI.Attr | SizeOf Inclusion.ParamArg | null | false |
UInt8.toBitVec_ofBitVec | Init.Data.UInt.Lemmas | ∀ (n : BitVec 8), { toBitVec := n }.toBitVec = n | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_8 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1),
⟨k, ⋯⟩ ≤ ⟨k + 1, ⋯⟩ | null | false |
BoundedContinuousFunction.coe_toContinuousMap | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
(f : BoundedContinuousFunction α β), ⇑f.toContinuousMap = ⇑f | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.tdiv_le_tdiv._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (a b c : ℤ), a + (b + c) = a + b + c | null | false |
Nat.one_add_le_iff | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, 1 + m ≤ n ↔ m < n | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Mathlib.Meta.Positivity.evalTheta.match_4 | Mathlib.NumberTheory.Chebyshev | {u : Lean.Level} →
{α : Q(Type u)} →
(motive : Option Q(PartialOrder «$α») → Sort u_1) →
(pα? : Option Q(PartialOrder «$α»)) →
(Unit → motive none) → ((val : Q(PartialOrder «$α»)) → motive (some val)) → motive pα? | null | false |
CategoryTheory.SheafOfTypes.balanced | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[CategoryTheory.HasSheafify J (Type w)], CategoryTheory.Balanced (CategoryTheory.Sheaf J (Type w)) | null | true |
_private.Mathlib.Computability.AkraBazzi.SumTransform.0.AkraBazziRecurrence.eventually_atTop_sumTransform_le._simp_1_3 | Mathlib.Computability.AkraBazzi.SumTransform | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Add α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}, (a - b ≤ c) = (a ≤ c + b) | null | false |
_private.Lean.Parser.Extension.0.Lean.Parser.optionValueToDataValue?.match_1 | Lean.Parser.Extension | (motive : Lean.Syntax → Sort u_1) →
(val : Lean.Syntax) →
((info : Lean.SourceInfo) → motive (Lean.Syntax.atom info "false")) → ((x : Lean.Syntax) → motive x) → motive val | null | false |
MultilinearMap.mkContinuousLinear_norm_le' | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} {G' : Type wG'} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[inst_6 ... | null | true |
OrderDual.instSemilatticeSup | Mathlib.Order.Lattice | (α : Type u_1) → [h : SemilatticeInf α] → SemilatticeSup αᵒᵈ | null | true |
Polynomial.Monic.mul_right_ne_zero | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → ∀ {q : Polynomial R}, q ≠ 0 → p * q ≠ 0 | null | true |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.List.splitWrtCompositionAux.match_3.eq_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {α : Type u_1} (motive : List α → List ℕ → Sort u_2) (x : List α) (h_1 : (x : List α) → motive x [])
(h_2 : (l : List α) → (n : ℕ) → (ns : List ℕ) → motive l (n :: ns)),
(match x, [] with
| x, [] => h_1 x
| l, n :: ns => h_2 l n ns) =
h_1 x | null | true |
Mathlib.Tactic.ClickSuggestions.instOrdResult | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} → [Ord α] → Ord (Mathlib.Tactic.ClickSuggestions.Result α) | null | true |
Module.Basis.coord_toDualEquiv_symm_apply | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) [inst_4 : Finite ι] (i : ι) (f : Module.Dual R M),
(b.coord i) (b.toDualEquiv.symm f) = (b.dualBasis.coord i) f | null | true |
irrational_natCast_sub_iff._simp_1 | Mathlib.NumberTheory.Real.Irrational | ∀ {n : ℕ} {x : ℝ}, Irrational (↑n - x) = Irrational x | null | false |
CommRingCat.Colimits.ColimitType.instAdd._proof_1 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(_x x' : CommRingCat.Colimits.Prequotient F),
_x ≈ x' → ∀ (y _y' : CommRingCat.Colimits.Prequotient F), y ≈ _y' → _x.add y ≈ x'.add _y' | null | false |
TensorAlgebra.instNontrivial | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Nontrivial R],
Nontrivial (TensorAlgebra R M) | A `TensorAlgebra` over a nontrivial semiring is nontrivial. | true |
ImportGraph.Lake.instHashableStdVer_importGraph | ImportGraph.Util.Modules | Hashable Lake.StdVer | null | true |
FreeAddGroup.map.mk | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {β : Type v} {f : α → β},
(FreeAddGroup.map f) (FreeAddGroup.mk L) = FreeAddGroup.mk (List.map (fun x => (f x.1, x.2)) L) | null | true |
Matroid.IsCocircuit.isCircuit | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {K : Set α}, M.IsCocircuit K → M✶.IsCircuit K | null | true |
Lean.Meta.SynthInstance.instInhabitedConsumerNode | Lean.Meta.SynthInstance | Inhabited Lean.Meta.SynthInstance.ConsumerNode | null | true |
AddConjClasses.map.eq_1 | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} {β : Type v} [inst : AddMonoid α] [inst_1 : AddMonoid β] (f : α →+ β),
AddConjClasses.map f = Quotient.lift (AddConjClasses.mk ∘ ⇑f) ⋯ | null | true |
BotHom.dual_symm_apply_apply | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : OrderBot α] [inst_2 : LE β] [inst_3 : OrderBot β]
(f : TopHom αᵒᵈ βᵒᵈ) (a : αᵒᵈ), (BotHom.dual.symm f) a = f a | null | true |
AddLocalization.mk_self | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} (a : ↥S), AddLocalization.mk (↑a) a = 0 | null | true |
Lean.instToExprDeclarationRange | Lean.Data.DeclarationRange | Lean.ToExpr Lean.DeclarationRange | null | true |
AddOpposite.op_surjective | Mathlib.Algebra.Opposites | ∀ {α : Type u_1}, Function.Surjective AddOpposite.op | null | true |
IsPurelyInseparable.exponent_def | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_2) {L : Type u_3} [inst : CommRing K] [inst_1 : Ring L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable.HasExponent K L] (a : L),
a ^ ringExpChar K ^ IsPurelyInseparable.exponent K L ∈ (algebraMap K L).range | null | true |
UpperSet.instAdd._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α] (s t : UpperSet α),
IsUpperSet (s.carrier + ↑t) | null | false |
Std.DHashMap.Raw.Const.get_insert | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h : m.WF) {k a : α} {v : β} {h₁ : a ∈ m.insert k v},
Std.DHashMap.Raw.Const.get (m.insert k v) a h₁ = if h₂ : (k == a) = true then v else Std.DHashMap.Raw.Const.get... | null | true |
LinearMap.continuousLinearMapClassOfFiniteDimensional | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] {F' : Type x} [inst_5 : AddCommGroup F']
[inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [IsTopologicalAddGroup F'] [C... | null | true |
OrderEmbedding.addLeft.eq_1 | Mathlib.Algebra.Order.Monoid.Basic | ∀ {α : Type u_2} [inst : Add α] [inst_1 : LinearOrder α] [inst_2 : AddLeftStrictMono α] (m : α),
OrderEmbedding.addLeft m = OrderEmbedding.ofStrictMono (fun n => m + n) ⋯ | null | true |
_private.Lean.Elab.Tactic.Split.0.Lean.Elab.Tactic.evalSplit.throwTermUnsupported | Lean.Elab.Tactic.Split | Lean.Term → Option Lean.Syntax → Lean.Elab.Tactic.TacticM Unit | null | true |
Filter.Realizer.inf._proof_1 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_3} {f g : Filter α} (F : f.Realizer) (G : g.Realizer) (x x_1 : F.σ × G.σ),
F.F.f (F.F.inf x.1 x_1.1) ∩ G.F.f (G.F.inf x.2 x_1.2) ⊆ F.F.f x.1 ∩ G.F.f x.2 | null | false |
_private.Mathlib.FieldTheory.Finite.Basic.0.ZMod.pow_card_sub_one._simp_1_1 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] [inst_3 : Sub α]
[OrderedSub α] {a b : α}, (a - b = 0) = (a ≤ b) | null | false |
_private.Mathlib.Topology.MetricSpace.GromovHausdorffRealized.0.GromovHausdorff.dist_mem_candidates._simp_1_3 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ {X : Type u} {Y : Type v} [inst : MetricSpace X] [inst_1 : MetricSpace Y] {x y : X ⊕ Y} [CompactSpace X] [Nonempty X]
[CompactSpace Y] [Nonempty Y], (dist x y ≤ ↑(GromovHausdorff.maxVar✝ X Y)) = True | null | false |
Lean.Lsp.SymbolKind.string.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.string = 1 | null | true |
LatticeCon.sup | Mathlib.Order.Lattice.Congruence | ∀ {α : Type u_2} [inst : Lattice α] (self : LatticeCon α) {w x y z : α},
self.toSetoid w x → self.toSetoid y z → self.toSetoid (w ⊔ y) (x ⊔ z) | null | true |
AnalyticOnNhd.eqOn_zero_or_eventually_ne_zero_of_preconnected | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜},
AnalyticOnNhd 𝕜 f U → IsPreconnected U → Set.EqOn f 0 U ∨ ∀ᶠ (x : 𝕜) in Filter.codiscreteWithin U, f x ≠ 0 | null | true |
BddBelow.of_upperClosure | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, BddBelow ↑(upperClosure s) → BddBelow s | **Alias** of the forward direction of `bddBelow_upperClosure`. | true |
SimpleGraph.Walk.dropUntil_first | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v u : V} [inst : DecidableEq V] (p : G.Walk u v) (h : u ∈ p.support),
p.dropUntil u h = p | null | true |
_private.Mathlib.NumberTheory.ModularForms.Derivative.0.Derivative.normalizedDerivOfComplex_slash._proof_1_3 | Mathlib.NumberTheory.ModularForms.Derivative | ContinuousSMul ℂ ℂ | null | false |
contDiff_omega_iff_analyticOnNhd | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F},
ContDiff 𝕜 ⊤ f ↔ AnalyticOnNhd 𝕜 f Set.univ | null | true |
DedekindCut.principal_le_principal._simp_1 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (DedekindCut.principal a ≤ DedekindCut.principal b) = (a ≤ b) | null | false |
Lean.Compiler.LCNF.Simp.FunDeclInfo.recOn | Lean.Compiler.LCNF.Simp.FunDeclInfo | {motive : Lean.Compiler.LCNF.Simp.FunDeclInfo → Sort u} →
(t : Lean.Compiler.LCNF.Simp.FunDeclInfo) →
motive Lean.Compiler.LCNF.Simp.FunDeclInfo.once →
motive Lean.Compiler.LCNF.Simp.FunDeclInfo.many → motive Lean.Compiler.LCNF.Simp.FunDeclInfo.mustInline → motive t | null | false |
cocompact_eq_atTop | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [NoMaxOrder α] [OrderBot α] [ClosedIciTopology α]
[CompactIccSpace α], Filter.cocompact α = Filter.atTop | null | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR.run.match_1.splitter | Init.Data.List.Sort.Impl | {α : Type u_1} →
(n : ℕ) →
(motive : { l // l.length = (n + 2 + 1) / 2 } × { l // l.length = (n + 2) / 2 } → Sort u_2) →
(x : { l // l.length = (n + 2 + 1) / 2 } × { l // l.length = (n + 2) / 2 }) →
((l : { l // l.length = (n + 2 + 1) / 2 }) → (r : { l // l.length = (n + 2) / 2 }) → motive (l, r)) →... | null | true |
CategoryTheory.Equivalence.instMonoidalInverseTrans._proof_9 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_4} [inst_4 : CategoryTheory.Category.{u_3, u_4} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
Lean.Omega.LinearCombo.coordinate_eval_6 | Init.Omega.LinearCombo | ∀ {a0 a1 a2 a3 a4 a5 a6 : ℤ} {t : List ℤ},
(Lean.Omega.LinearCombo.coordinate 6).eval (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: t)) =
a6 | null | true |
AddAction.orbitRel_le_fst | Mathlib.GroupTheory.GroupAction.Basic | ∀ (G : Type u_1) (α : Type u_2) (β : Type u_3) [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : AddAction G β],
AddAction.orbitRel G (α × β) ≤ Setoid.comap Prod.fst (AddAction.orbitRel G α) | null | true |
Lean.Meta.Diagnostics.synthPendingFailures | Lean.Meta.Basic | Lean.Meta.Diagnostics → Lean.PHashMap Lean.Expr Lean.MessageData | Pending instances that were not synthesized because `maxSynthPendingDepth` has been reached. | true |
CategoryTheory.Dial.associatorImpl._proof_2 | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X Y Z : CategoryTheory.Dial C),
((X.tensorObjImpl Y).tensorObjImpl Z).rel =
(CategoryTheory.Subobject.pullback
(CategoryTheory.Limits.pro... | null | false |
CochainComplex.HomComplex.Cocycle.toSingleMk_smul._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
{K : CochainComplex C ℤ} {R : Type u_3} [inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] (r : R) {p : ℤ}
(f : K.X p ⟶ X) (p' : ℤ),
CategoryTheory.CategoryStruct.comp (K.d p' p) f = 0 → CategoryTheo... | null | false |
ValuationSubring.ofSubring_toSubring | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (R : Subring K) (hR : ∀ (x : K), x ∈ R ∨ x⁻¹ ∈ R),
(ValuationSubring.ofSubring R hR).toSubring = R | null | true |
Lean.Grind.CommRing.powerRevlex_k.eq_1 | Init.Grind.Ring.CommSolver | ∀ (k₁ k₂ : ℕ),
Lean.Grind.CommRing.powerRevlex_k k₁ k₂ =
Bool.rec (Bool.rec Ordering.eq Ordering.lt (k₂.blt k₁)) Ordering.gt (k₁.blt k₂) | null | true |
CategoryTheory.InjectiveResolution.homotopyEquiv_inv_ι | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(I J : CategoryTheory.InjectiveResolution X), CategoryTheory.CategoryStruct.comp J.ι (I.homotopyEquiv J).inv = I.ι | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rotateLeftAux_of_ge._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w r i : ℕ}, i ≥ w - r → i < w - r → False | null | false |
Nat.lcm_dvd_iff | Init.Data.Nat.Lcm | ∀ {m n k : ℕ}, m.lcm n ∣ k ↔ m ∣ k ∧ n ∣ k | null | true |
Topology.WithUpperSet.instNonempty | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [Nonempty α], Nonempty (Topology.WithUpperSet α) | null | true |
Profinite.NobelingProof.Proj.eq_1 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u} (J : I → Prop) [inst : (i : I) → Decidable (J i)] (c : I → Bool) (i : I),
Profinite.NobelingProof.Proj J c i = if J i then c i else false | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.Basic.0.algebraicIndependent_finset_map_embedding_subtype._simp_1_1 | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), (↑a ∈ S) = True | null | false |
_private.Mathlib.Logic.Equiv.Set.0.dite_comp_equiv_update._proof_1_3 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_4} {E : Type u_3} {β : Sort u_2} {γ : Sort u_1} {p : α → Prop} [inst : EquivLike E { x // p x } β] (e : E)
(v : β → γ) (w : α → γ) (j : β) (x : γ) [inst_1 : DecidableEq β] [inst_2 : DecidableEq α]
[inst_3 : (j : α) → Decidable (p j)] (i : α),
¬p i →
(if h : p i then Function.update v j x (e ⟨i, ... | null | false |
Std.DHashMap.Equiv.congr_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.DHashMap α β},
m₁.Equiv m₂ → (m₃.Equiv m₁ ↔ m₃.Equiv m₂) | null | true |
AddGroup.nilpotencyClass.eq_1 | Mathlib.GroupTheory.Nilpotent | ∀ (G : Type u_1) [inst : AddGroup G], AddGroup.nilpotencyClass G = if hG : AddGroup.IsNilpotent G then Nat.find ⋯ else 0 | null | true |
Std.IterM.toArray_mapM_eq_toArray_mapWithPostcondition | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Monad m] [LawfulMonad m] [inst_2 : Monad n]
[inst_3 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n] [inst_6 : MonadLiftT m n] [LawfulMonadLiftT m n]
[inst : Std.Iterator α m β] [Std.Iterators.Finite α m] {f : β → n γ} {it : Std.I... | null | true |
Std.DTreeMap.Internal.Impl.getKey?_filter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
[inst_1 : Std.LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF),
(Std.DTreeMap.Internal.Impl.filter! f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (t.get x ⋯) | null | true |
Lean.Linter.CodeQualityLogEntry.mk.noConfusion | Lean.Linter.PersistentLintLog | {P : Sort u} →
{linter? : Option Lean.Name} →
{entry : Lean.Linter.CodeQuality.Entry} →
{linter?' : Option Lean.Name} →
{entry' : Lean.Linter.CodeQuality.Entry} →
{ linter? := linter?, entry := entry } = { linter? := linter?', entry := entry' } →
(linter? = linter?' → entry = e... | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.vectorMeasure_Ioi._proof_1_3 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] [inst_2 : TopologicalSpace α]
[inst_3 : OrderTopology α] [inst_4 : SecondCountableTopology α] [inst_5 : CompactIccSpace α] [hα : MeasurableSpace α]
[inst_6 : BorelSpace α] {E : Type u_1} [inst_7 : NormedAddCommGroup E] [inst_8 : CompleteSpace E] {f... | null | false |
Ideal.trivialFiltration._proof_1 | Mathlib.RingTheory.Filtration | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
(x : ℕ), N ≤ N | null | false |
Module.Relations.tensor_relation | Mathlib.Algebra.Module.Presentation.Tensor | ∀ {A : Type u} [inst : CommRing A] (relations₁ : Module.Relations A) (relations₂ : Module.Relations A)
(x : relations₁.R × relations₂.G ⊕ relations₁.G × relations₂.R),
(relations₁.tensor relations₂).relation x =
match x with
| Sum.inl (r₁, g₂) => Finsupp.embDomain (Function.Embedding.sectL relations₁.G g₂) ... | null | true |
Lean.Compiler.LCNF.ImpureType.erased | Lean.Compiler.LCNF.Types | Lean.Expr | `erased` represents type arguments, propositions and proofs which are no longer relevant at this
point in time.
| true |
Metric.unitClosedBall.instMonoid | Mathlib.Analysis.Normed.Field.UnitBall | {𝕜 : Type u_1} → [inst : SeminormedRing 𝕜] → [NormOneClass 𝕜] → Monoid ↑(Metric.closedBall 0 1) | null | true |
nnnorm_cfcₙ_le_iff._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
Lean.Omega.Int.ofNat_pos | Init.Omega.Int | ∀ {a : ℕ}, 0 < ↑a ↔ 0 < a | null | true |
SupBotHom.copy_eq | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Max α] [inst_1 : Bot α] [inst_2 : Max β] [inst_3 : Bot β] (f : SupBotHom α β)
(f' : α → β) (h : f' = ⇑f), f.copy f' h = f | null | true |
Complex.arg_nonneg_iff._simp_1 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {z : ℂ}, (0 ≤ z.arg) = (0 ≤ z.im) | null | false |
AddMonCat.FilteredColimits.colimitDesc._proof_2 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J AddMonCat)
[inst_1 : CategoryTheory.IsFiltered J] (t : CategoryTheory.Limits.Cocone F) (x y : AddMonCat.FilteredColimits.M F),
(F.comp (CategoryTheory.forget AddMonCat)).descColimitType
((F.comp (CategoryTheory.forget AddMo... | null | false |
Filter.map_atBot_eq_of_gc_preorder | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [IsCodirectedOrder α] [inst_2 : Preorder β] [IsCodirectedOrder β]
{f : α → β},
Monotone f →
∀ (b : β), (∀ c ≤ b, ∃ x, f x = c ∧ ∀ (a : α), c ≤ f a ↔ x ≤ a) → Filter.map f Filter.atBot = Filter.atBot | A function `f` maps downwards closed sets (atBot sets) to downwards closed sets when it is a
Galois coinsertion. The Galois "coinsertion" and "connection" is weakened to only require it to be
an insertion and a connection below `b`. | true |
CategoryTheory.Limits.mapPair.match_5 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | ∀ (X : CategoryTheory.Limits.WalkingPair)
(motive : (x : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) → ({ as := X } ⟶ x) → Prop)
(x : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) (x_1 : { as := X } ⟶ x),
(∀ (Y : CategoryTheory.Limits.WalkingPair) (x : { as := X } ⟶ { as := Y }), motiv... | null | false |
LieEquiv.casesOn | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{L' : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : LieRing L'] →
[inst_4 : LieAlgebra R L'] →
{motive : (L ≃ₗ⁅R⁆ L') → Sort u_1} →
(t : L ≃ₗ⁅R⁆ L') →
... | null | false |
Std.Ric.eq_succMany?_of_toArray_eq_append_append._proof_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} {r : Std.Ric α} [inst : Std.PRange.Least? α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[inst_5 : Std.Rxc.IsAlwaysFinite α] {pref suff : Array α} {cur : α},
r.toArray = pref ++ #[cur] ++ suff → pref.size < r.toA... | null | false |
Lean.Lsp.DiagnosticWith.source? | Lean.Data.Lsp.Diagnostics | {α : Type} → Lean.Lsp.DiagnosticWith α → Option String | A human-readable string describing the source of this diagnostic, e.g. 'typescript' or 'super lint'. | true |
AddGroupNormClass.toNormedAddCommGroup_norm_eq | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddCommGroup α] [inst_2 : AddGroupNormClass F α ℝ]
(f : F) (x : α), ‖x‖ = f x | null | true |
_private.Mathlib.Analysis.CStarAlgebra.Spectrum.0.NonUnitalStarAlgHom.nnnorm_apply_le._simp_1_2 | Mathlib.Analysis.CStarAlgebra.Spectrum | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {inst : Star R} {inst_1 : Star S}
{inst_2 : FunLike F R S} [self : StarHomClass F R S] (f : F) (r : R), star (f r) = f (star r) | null | false |
Complex.IsExpCmpFilter.mk | Mathlib.Analysis.SpecialFunctions.CompareExp | ∀ {l : Filter ℂ},
Filter.Tendsto Complex.re l Filter.atTop →
(∀ (n : ℕ), (fun z => z.im ^ n) =O[l] fun z => Real.exp z.re) → Complex.IsExpCmpFilter l | null | true |
definition._@.Mathlib.Topology.Algebra.InfiniteSum.Defs.1210274395._hygCtx._hyg.8 | Mathlib.Topology.Algebra.InfiniteSum.Defs | {α : Type u_1} →
{β : Type u_2} →
[CommMonoid α] → [TopologicalSpace α] → (β → α) → optParam (SummationFilter β) (SummationFilter.unconditional β) → α | null | false |
SeparationQuotient.uniformContinuous_map | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] (f : α → β),
UniformContinuous (SeparationQuotient.map f) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.