name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CauSeq.Completion.Cauchy.field._proof_6 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_1}
[inst_3 : Field β] {abv : β → α} [inst_4 : IsAbsoluteValue abv], Nontrivial (CauSeq.Completion.Cauchy abv) | null | false |
groupCohomology.functor | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | (k G : Type u) → [inst : CommRing k] → [inst_1 : Group G] → ℕ → CategoryTheory.Functor (Rep.{u, u, u} k G) (ModuleCat k) | The functor sending a `G`-representation `A` to `Hⁿ(G, A)`. | true |
MeasureTheory.StronglyMeasurable.div₀ | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β]
[inst_1 : GroupWithZero β] [ContinuousMul β] [ContinuousInv₀ β],
MeasureTheory.StronglyMeasurable f →
MeasureTheory.StronglyMeasurable g → (∀ (x : α), g x ≠ 0) → MeasureTheory.StronglyMeasurable (f / g) | null | true |
Equiv.apply_eq_iff_eq_symm_apply | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {x : α} {y : β} (f : α ≃ β), f x = y ↔ x = f.symm y | null | true |
contractRight_apply | Mathlib.LinearAlgebra.Contraction | ∀ {R : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f : Module.Dual R M) (m : M), (contractRight R M) (m ⊗ₜ[R] f) = f m | null | true |
Std.Async.DNS.NameInfo.service | Std.Async.DNS | Std.Async.DNS.NameInfo → String | The service name (e.g., "http" for port 80).
| true |
WithZero.instDivisionMonoid.match_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} (motive : WithZero α → WithZero α → Prop) (x x_1 : WithZero α),
(∀ (_ : Unit), motive none none) →
(∀ (val : α), motive none (some val)) →
(∀ (val : α), motive (some val) none) → (∀ (val val_1 : α), motive (some val) (some val_1)) → motive x x_1 | null | false |
Lean.ClassState._sizeOf_inst | Lean.Class | SizeOf Lean.ClassState | null | false |
SemilatInfCat.instConcreteCategoryInfTopHomX._proof_3 | Mathlib.Order.Category.Semilat | ∀ {X : SemilatInfCat} (x : X.X), (CategoryTheory.CategoryStruct.id X) x = x | null | false |
UniformSpace.Completion.completionSeparationQuotientEquiv._proof_2 | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α] (a : UniformSpace.Completion α),
UniformSpace.Completion.extension (SeparationQuotient.lift' UniformSpace.Completion.coe')
(UniformSpace.Completion.map SeparationQuotient.mk a) =
a | null | false |
of_eq_false | Init.SimpLemmas | ∀ {p : Prop}, p = False → ¬p | null | true |
_private.Mathlib.NumberTheory.ZetaValues.0.bernoulliFun_mul._simp_1_2 | Mathlib.NumberTheory.ZetaValues | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
ContinuousLinearMapWOT.instAddCommGroup | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
{σ : 𝕜₁ →+* 𝕜₂} →
{E : Type u_3} →
{F : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : Module 𝕜₁ E... | null | true |
Pi.instLTLexForall | Mathlib.Order.PiLex | {ι : Type u_1} → {β : ι → Type u_2} → [LT ι] → [(a : ι) → LT (β a)] → LT (Lex ((i : ι) → β i)) | null | true |
AlternatingMap.domLCongr._proof_1 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ (R : Type u_1) [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (N : Type u_3)
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (ι : Type u_4) {M₂ : Type u_5} [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₂] (e : M ≃ₗ[R] M₂) (x x_1 : M [⋀^ι]→ₗ[R] N),
(x + x_1).compLinearMap ... | null | false |
_private.Mathlib.NumberTheory.Padics.Measure.Basic.0.AbstractMeasure.prodMk'_prod_apply._simp_1_1 | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | null | false |
Manifold.IsSubmersion.instNormedAddCommGroupComplement | Mathlib.Geometry.Manifold.Submersion | {𝕜 : Type u_1} →
{E'' : Type u_3} →
{H : Type u_7} →
{G : Type u_9} →
{E : Type u} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup E''] →
[inst_... | null | true |
Real.cos_add | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), Real.cos (x + y) = Real.cos x * Real.cos y - Real.sin x * Real.sin y | null | true |
pointedToTwoPSndForgetCompBipointedToPointedSndAdjunction._proof_5 | Mathlib.CategoryTheory.Category.TwoP | ∀ (X : Pointed) (Y : TwoP) (f : pointedToTwoPSnd.obj X ⟶ Y),
f.hom.toFun (pointedToTwoPSnd.obj X).toBipointed.toProd.2 = Y.toBipointed.toProd.2 | null | false |
_private.Batteries.Util.ProofWanted.0.WantedRefKind.accessor | Batteries.Util.ProofWanted | WantedRefKind✝ → Lean.Name | The accessor that reduces `<wrapper> foo` to `foo`'s recorded statement/type. | true |
ArithmeticFunction.vonMangoldt_sum | Mathlib.NumberTheory.ArithmeticFunction.VonMangoldt | ∀ {n : ℕ}, ∑ i ∈ n.divisors, ArithmeticFunction.vonMangoldt i = Real.log ↑n | null | true |
IsEvenlyCovered.subtypeVal_comp | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] (s : Set X) {I : Type u_3}
[inst_2 : TopologicalSpace I],
IsOpen s → ∀ {x : ↑s} {f : E → ↑s}, IsEvenlyCovered f x I → IsEvenlyCovered (Subtype.val ∘ f) (↑x) I | null | true |
Matrix.blockDiag'_transpose | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_11}
(M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (k : o), M.transpose.blockDiag' k = (M.blockDiag' k).transpose | null | true |
Finmap.union_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : AList β), s₁.toFinmap ∪ s₂.toFinmap = (s₁ ∪ s₂).toFinmap | null | true |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.registerFailedToInferDefTypeInfo._sparseCasesOn_7 | Lean.Elab.MutualDef | {motive : Lean.Elab.DefKind → Sort u} →
(t : Lean.Elab.DefKind) →
motive Lean.Elab.DefKind.example →
motive Lean.Elab.DefKind.instance →
motive Lean.Elab.DefKind.theorem → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorBinaryRefVecBlastUmod | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.BinaryRefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastUmod | null | true |
CategoryTheory.Abelian.LeftResolution.chainComplexMap_f_succ_succ | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) {X Y : A} (f : X ⟶ Y) [inst_2 : ι.Full] [inst_3 : ι.Faithful]
[inst_4 : CategoryTheory.Limits.HasZeroMorphism... | null | true |
instMulActionRayVector._proof_1 | Mathlib.LinearAlgebra.Ray | ∀ {M : Type u_1} [inst : AddCommMonoid M] {G : Type u_2} [inst_1 : Group G] [inst_2 : DistribMulAction G M] (r : G)
(x : M), x ≠ 0 → r • x ≠ 0 | null | false |
AntivaryOn.card_mul_sum_le_sum_mul_sum | Mathlib.Algebra.Order.Chebyshev | ∀ {ι : Type u_1} {α : Type u_2} [inst : Semiring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [ExistsAddOfLE α]
{s : Finset ι} {f g : ι → α}, AntivaryOn f g ↑s → ↑s.card * ∑ i ∈ s, f i * g i ≤ (∑ i ∈ s, f i) * ∑ i ∈ s, g i | **Chebyshev's Sum Inequality**: When `f` and `g` antivary together (e.g. one is monotone, the
other is antitone), the product of their sum is greater than the size of the set times their scalar
product. | true |
PSigma.fintypePropRight.match_5 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} {β : α → Prop} (motive : { a // β a } → Prop) (x : { a // β a }),
(∀ (val : α) (property : β val), motive ⟨val, property⟩) → motive x | null | false |
AlgebraicGeometry.IsClosedImmersion.lift_fac | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsClosedImmersion f]
(H : AlgebraicGeometry.Scheme.Hom.ker f ≤ AlgebraicGeometry.Scheme.Hom.ker g),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsClosedImmersion.lift f g H) f = g | null | true |
Aesop.CoreRuleBuilderOutput.noConfusion | Aesop.Builder.Basic | {P : Sort u} → {t t' : Aesop.CoreRuleBuilderOutput} → t = t' → Aesop.CoreRuleBuilderOutput.noConfusionType P t t' | null | false |
Continuous.compCM | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [LocallyCompactPair Y Z] {X' : Type u_6} [inst_4 : TopologicalSpace X']
{g : X' → C(Y, Z)} {f : X' → C(X, Y)}, Continuous g → Continuous f → Continuous fun x => (g x).comp (f x) | null | true |
Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α},
Nat.card ↥(Equiv.Perm.OnCycleFactors.toPermHom g).range =
∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType).factorial | null | true |
Representation.le_stabilizer_sum | Mathlib.RepresentationTheory.Stabilizer | ∀ {k : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Semiring k] {V : Type u_3} [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] {ι : Type u_5} [inst_4 : Fintype ι] (ρ : Representation k G V) (v : ι → V),
⨅ i, ρ.stabilizer (v i) ≤ ρ.stabilizer (∑ i, v i) | null | true |
_private.Lean.Meta.Tactic.Grind.ForallProp.0._regBuiltin.Lean.Meta.Grind.simpForall.declare_35._@.Lean.Meta.Tactic.Grind.ForallProp.4143869776._hygCtx._hyg.12 | Lean.Meta.Tactic.Grind.ForallProp | IO Unit | null | false |
NonUnitalStarAlgebra.elemental.isClosedEmbedding_coe | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] [inst_8 : TopologicalSpace A] [inst_9 : IsSemitopologicalSemiring A]
[ins... | The coercion from an elemental algebra to the full algebra is a `IsClosedEmbedding`. | true |
String.startsWith_char_iff_get | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {c : Char} {s : String}, s.startsWith c = true ↔ ∃ (h : s.startPos ≠ s.endPos), s.startPos.get h = c | null | true |
CategoryTheory.Conv.instMul | Mathlib.CategoryTheory.Monoidal.Conv | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : C} → [CategoryTheory.ComonObj M] → [CategoryTheory.MonObj N] → Mul (CategoryTheory.Conv M N) | null | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.getElem?_toList._simp_1_4 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} {a : α} {p : Prop} {x : Decidable p} {b : Option α},
((if p then b else none) = some a) = (p ∧ b = some a) | null | false |
LaurentPolynomial.degree_T_le | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (n : ℤ), (LaurentPolynomial.T n).degree ≤ ↑n | null | true |
Real.fderiv_fourier | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E},
MeasureTheory.Integrable f MeasureTheory.volume →
Measure... | The Fréchet derivative of the Fourier transform of `f` is the Fourier transform of
`fun v ↦ -2 * π * I ⟪v, ⬝⟫ f v`. | true |
CategoryTheory.FinCategory.mk | Mathlib.CategoryTheory.FinCategory.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
autoParam (Fintype J) CategoryTheory.FinCategory.fintypeObj._autoParam →
autoParam ((j j' : J) → Fintype (j ⟶ j')) CategoryTheory.FinCategory.fintypeHom._autoParam →
CategoryTheory.FinCategory J | null | true |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.zariskisMainProperty_iff_exists_saturation_eq_top._simp_1 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {M : Type u_1} [inst : Monoid M] {n : M} {P : Submonoid M}, (Submonoid.powers n ≤ P) = (n ∈ P) | null | false |
mem_tangentConeAt_of_add_smul_mem | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : DivisionSemiring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace 𝕜] [inst_4 : TopologicalSpace E] [ContinuousSMul 𝕜 E] {s : Set E} {x y : E} {α : Type u_3}
{l : Filter α} [l.NeBot] {c : α → 𝕜},
Filter.Tendsto c l (nhdsWithin 0 {0}ᶜ) → (∀ᶠ... | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.termTry._regBuiltin.Lean.Parser.Term.termTry.parenthesizer_11 | Lean.Parser.Do | IO Unit | null | false |
AddSubgroup.index | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : AddGroup G] → AddSubgroup G → ℕ | The index of an additive subgroup as a natural number.
Returns 0 if the index is infinite.
[Wikidata Q1464168](https://www.wikidata.org/wiki/Q1464168) | true |
NumberField.mixedEmbedding.convexBodyLT'_volume | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] (f : NumberField.InfinitePlace K → NNReal) (w₀ : { w // w.IsComplex })
[inst_1 : NumberField K],
MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT' K f w₀) =
↑(NumberField.mixedEmbedding.convexBodyLT'Factor K) * ↑(∏ w, f w ^ w.mult) | null | true |
Std.ExtTreeMap.toList_inj | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {t₁ t₂ : Std.ExtTreeMap α β cmp},
t₁.toList = t₂.toList ↔ t₁ = t₂ | null | true |
Num.commSemiring._proof_4 | Mathlib.Data.Num.Lemmas | ∀ (a b c : Num), a * b * c = a * (b * c) | null | false |
ContinuousLinearMapWOT.postcompCLM._proof_2 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_6} {E : Type u_3} {F : Type u_4} {G : Type u_5} [inst : NormedField 𝕜₁]
[inst_1 : NormedField 𝕜₂] [inst_2 : NormedField 𝕜₃] {σ₁₂ : 𝕜₁ →+* 𝕜₂} {σ₁₃ : 𝕜₁ →+* 𝕜₃} {σ₂₃ : 𝕜₂ →+* 𝕜₃}
[inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_4 : AddCommGroup E] [inst_5 : To... | null | false |
Lean.PersistentHashMap.findAux | Lean.Data.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → [BEq α] → Lean.PersistentHashMap.Node α β → USize → α → Option β | null | true |
QuotientAddGroup.Quotient.addGroup._proof_14 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (N : AddSubgroup G) [nN : N.Normal] (a : G ⧸ N), -a + a = 0 | null | false |
MeasureTheory.integrable_stoppedValue_of_mem_finset | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Nonempty ι] {μ : MeasureTheory.Measure Ω}
{τ : Ω → WithTop ι} {E : Type u_4} {u : ι → Ω → E} [inst_1 : PartialOrder ι] {ℱ : MeasureTheory.Filtration ι m}
[inst_2 : NormedAddCommGroup E],
MeasureTheory.IsStoppingTime ℱ τ →
(∀ (n : ι), MeasureTheor... | null | true |
Colex.instPow._aux_1 | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → {β : Type u_2} → [Pow α β] → Pow (Colex α) β | null | false |
Lean.Sym.Nat.eq_eq_true | Init.Sym.Lemmas | ∀ (a b : ℕ), decide (a = b) = true → (a = b) = True | null | true |
Std.IO.Process.PId.mk | Std.Async.Process | UInt64 → Std.IO.Process.PId | null | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_top_eq_maxUnifEigenspaceIndex._simp_1_2 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
Bialgebra.toLinearMap_counitAlgHom | Mathlib.RingTheory.Bialgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A],
(Bialgebra.counitAlgHom R A).toLinearMap = CoalgebraStruct.counit | null | true |
MeasureTheory.L1.SimpleFunc.setToL1S_add_left | Mathlib.MeasureTheory.Integral.SetToL1.SimpleFunc | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(T T' : Set α → E →L[ℝ] F) (f : ↥(α →₁ₛ[μ] E)),
MeasureTheory.L1.SimpleFunc.setToL1S (T + T') f =... | null | true |
CategoryTheory.ChosenPullbacksAlong.Over.whiskerRight_left_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
{R S T : CategoryTheory.Over X} (f : S ⟶ T),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left (CategoryTheory.MonoidalCategoryStruct.whiskerRight f R))
(CategoryTheory.ChosenPu... | null | true |
ImportGraph.Shake.Lean.Import.andThen | ImportGraph.Shake.Algebra | ImportGraph.Shake.Needs → Lean.Import → ImportGraph.Shake.Needs | Given an abstract import `[k⟩` and a collection of prearrows `j [k⟩ ·` (`Needs`), forms
the composed prearrows `j [k'⟩[k⟩ ·` where composition is possible. | true |
instIsRightAdjointLightCondSetLightCondModForget | Mathlib.Condensed.Light.Module | ∀ (R : Type u) [inst : Ring R], (LightCondensed.forget R).IsRightAdjoint | null | true |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.comap_mem_associatedPrimes_of_mem_associatedPrimes_of_isLocalizedModule_of_fg._simp_1_1 | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] {f : F}
{K : Ideal S} [inst_3 : RingHomClass F R S] {x : R}, (f x ∈ K) = (x ∈ Ideal.comap f K) | null | false |
CategoryTheory.PreZeroHypercoverFamily.noConfusionType | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.PreZeroHypercoverFamily C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] → CategoryTheory.PreZeroHypercoverFamily C' → Sort u_1 | null | false |
HomotopicalAlgebra.CofibrantObject.HoCat | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | (C : Type u_1) → [inst : CategoryTheory.Category.{v_1, u_1} C] → [HomotopicalAlgebra.ModelCategory C] → Type u_1 | The homotopy category of cofibrant objects. | true |
PLift.instLawfulFunctor_mathlib | Mathlib.Control.ULift | LawfulFunctor PLift | null | true |
Lean.Meta.Sym.DSimp.Methods.post._default | Lean.Meta.Sym.DSimp.DSimpM | Lean.Expr → Lean.Meta.Sym.DSimp.DSimpM Lean.Meta.Sym.DSimp.Result | null | false |
RatFunc.X.eq_1 | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K],
RatFunc.X = (algebraMap (Polynomial K) (RatFunc K)) Polynomial.X | null | true |
RingCone.mem_mk | Mathlib.Algebra.Order.Ring.Cone | ∀ {R : Type u_1} [inst : Ring R] {toSubsemiring : Subsemiring R}
(eq_zero_of_mem_of_neg_mem : ∀ {a : R}, a ∈ toSubsemiring.carrier → -a ∈ toSubsemiring.carrier → a = 0) {x : R},
x ∈ { toSubsemiring := toSubsemiring, eq_zero_of_mem_of_neg_mem' := eq_zero_of_mem_of_neg_mem } ↔ x ∈ toSubsemiring | null | true |
List.lookmap | Batteries.Data.List.Basic | {α : Type u_1} → (α → Option α) → List α → List α | `lookmap` is a combination of `lookup` and `filterMap`.
`lookmap f l` will apply `f : α → Option α` to each element of the list,
replacing `a → b` at the first value `a` in the list such that `f a = some b`.
| true |
NormedSpace.invertibleExpOfMemBall._proof_1 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝕂 : Type u_2} {𝔸 : Type u_1} [inst : NontriviallyNormedField 𝕂] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸]
[CompleteSpace 𝔸] [CharZero 𝕂] {x : 𝔸},
x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius → NormedSpace.exp (-x) * NormedSpace.exp x = 1 | null | false |
Array.map_eq_empty_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α}, (Array.map f xs = #[]) = (xs = #[]) | null | false |
Associates.prime_mk | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {p : M}, Prime (Associates.mk p) ↔ Prime p | null | true |
bne_eq_false_iff_eq._simp_1 | Init.SimpLemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a != b) = false) = (a = b) | null | false |
AkraBazziRecurrence.recOn | Mathlib.Computability.AkraBazzi.SumTransform | {α : Type u_1} →
[inst : Fintype α] →
[inst_1 : Nonempty α] →
{T : ℕ → ℝ} →
{g : ℝ → ℝ} →
{a b : α → ℝ} →
{r : α → ℕ → ℕ} →
{motive : AkraBazziRecurrence T g a b r → Sort u} →
(t : AkraBazziRecurrence T g a b r) →
((n₀ : ℕ) →
... | null | false |
Equiv.trans_toEmbedding | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f : β ≃ γ),
(e.trans f).toEmbedding = e.toEmbedding.trans f.toEmbedding | null | true |
HomologicalComplex₂.totalShift₁Iso._proof_1 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (x : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(n n' : ℤ),
CategoryTheory.CategoryStruct.comp (K.totalShift₁XIso x n (n + x) ⋯).hom
((... | null | false |
CategoryTheory.NatIso.removeOp_hom | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (α : F.op ≅ G.op),
(CategoryTheory.NatIso.removeOp α).hom = CategoryTheory.NatTrans.removeOp α.hom | null | true |
CategoryTheory.Limits.IsColimit.map | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F G : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cocone G} →
CategoryTheory.Limits.IsColimit t → (s : CategoryTheory.Limits.Cocone F) → (... | Given a natural transformation `α : F ⟶ G`, we give a morphism from the cocone point
of a colimit cocone over `F` to the cocone point of any cocone over `G`. | true |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_11 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M)
(h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier) {x : M},
(x ∈ { toSubmodule := p, lie_mem := h }) = (x ∈ p) | null | false |
SSet.prodStdSimplex₁.filtration | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplexOne | {p : ℕ} →
Fin (p + 1) →
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { len := p })
(SSet.stdSimplex.obj { len := 1 })).Subcomplex | The filtration of `Δ[p] ⊗ Δ[1]` which sends `j : Fin (p + 1)` to the subcomplex
generated by the non-degenerate `(p + 1)`-simplices `nonDegenerateEquiv i` for `i ≤ j`. | true |
Prod.instDivInvMonoid._proof_4 | Mathlib.Algebra.Group.Prod | ∀ {G : Type u_1} {H : Type u_2} [inst : DivInvMonoid G] [inst_1 : DivInvMonoid H] (x : ℕ) (x_1 : G × H),
x_1 ^ Int.negSucc x = (x_1 ^ ↑x.succ)⁻¹ | null | false |
exists_quadratic_eq_zero | Mathlib.Algebra.QuadraticDiscriminant | ∀ {K : Type u_1} [inst : Field K] [NeZero 2] {a b c : K},
a ≠ 0 → (∃ s, discrim a b c = s * s) → ∃ x, a * (x * x) + b * x + c = 0 | A quadratic has roots if its discriminant has square roots | true |
CategoryTheory.Adjunction.whiskerRight_counit_app_app | Mathlib.CategoryTheory.Adjunction.Whiskering | ∀ (C : Type u_1) {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
{F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} (adj : F ⊣ G) (X : CategoryTheory.Functor C E)
(X_1 : C), (... | null | true |
_private.Mathlib.Data.Nat.Cast.Order.Ring.0.Nat.neg_cast_eq_cast._simp_1_1 | Mathlib.Data.Nat.Cast.Order.Ring | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (-a = b) = (a + b = 0) | null | false |
CategoryTheory.Limits.IsTerminal.strict_hom_ext | Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictTerminalObjects C] {I : C}
(hI : CategoryTheory.Limits.IsTerminal I) {A : C} (f g : I ⟶ A), f = g | null | true |
Function.const_neg' | Mathlib.Algebra.Order.Pi | ∀ {α : Type u_2} {β : Type u_3} [inst : Zero α] [inst_1 : Preorder α] {a : α} [Nonempty β],
Function.const β a < 0 ↔ a < 0 | null | true |
LinearMap.compMultilinearMap_compLinearMap | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₁' : ι → Type v₁'} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → AddCommMonoid (M₁' i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : AddCommMonoid M₃] [inst_5 : (i : ι) → Module R (M₁ i)] [inst_6 : (i : ι) ... | The two types of composition are associative. | true |
Option.instMembership | Init.Data.Option.Instances | {α : Type u_1} → Membership α (Option α) | null | true |
mulMulHom._proof_1 | Mathlib.Algebra.Group.Prod | ∀ {α : Type u_1} [inst : CommSemigroup α] (x x_1 : α × α), x.1 * x_1.1 * (x.2 * x_1.2) = x.1 * x.2 * (x_1.1 * x_1.2) | null | false |
CategoryTheory.StrictPseudofunctor.mk'._proof_7 | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictPseudofunctorCore B C) {a b : B} (f : a ⟶ b),
S.map₂ (CategoryTheory.CategoryStruct.id f) = CategoryTheory.CategoryStruct.id (S.map f) | null | false |
CategoryTheory.Triangulated.AbelianSubcategory.abelian | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | {C : Type u_1} →
{A : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additiv... | Let `ι : A ⥤ C` be a fully faithful additive functor where `A` is
an additive category and `C` is a triangulated category. The category `A`
is abelian if the following conditions are satisfied:
* For any object `X` and `Y` in `A`, there is no nonzero morphism
`ι.obj X ⟶ (ι.obj Y)⟦n⟧` when `n < 0`.
* Any morphism `f₁ ... | true |
ImportGraph.instInhabitedWorkspaceModel.default | ImportGraph.WorkspaceModel.Model | ImportGraph.WorkspaceModel | null | true |
Std.Tactic.BVDecide.Normalize.BitVec.not_neg' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (x : BitVec w), ~~~(x + 1#w) = ~~~x + -1#w | null | true |
BoundedContinuousFunction.norm_const_eq | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β] [h : Nonempty α] (b : β),
‖BoundedContinuousFunction.const α b‖ = ‖b‖ | null | true |
Set.projIci_of_mem | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} [inst : LinearOrder α] {a x : α} (hx : x ∈ Set.Ici a), Set.projIci a x = ⟨x, hx⟩ | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rcc_add_succ_right_eq_push'._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m ≤ m + n → False | null | false |
Std.DHashMap.Raw.Const.get?_insertIfNew | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a : α} {v : β},
Std.DHashMap.Raw.Const.get? (m.insertIfNew k v) a =
if (k == a) = true ∧ k ∉ m then some v else Std.DHashMap.Raw.Const.get? m a | null | true |
Lean.Meta.Grind.BuiltinPropagators.recOn | Lean.Meta.Tactic.Grind.PropagatorAttr | {motive : Lean.Meta.Grind.BuiltinPropagators → Sort u} →
(t : Lean.Meta.Grind.BuiltinPropagators) →
((up down : Lean.Meta.Grind.PropagatorMap) → motive { up := up, down := down }) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.