name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
affineIndependent_iff_linearIndependent_vsub | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {ι : Type u_4} (p : ι → P) (i1 : ι),
AffineIndependent k p ↔ LinearIndependent k fun i => p ↑i -ᵥ p i1 | A family is affinely independent if and only if the differences
from a base point in that family are linearly independent. | true |
CategoryTheory.LocalizerMorphism.functorialRightResolutions.ι._proof_1 | Mathlib.CategoryTheory.Localization.DerivabilityStructure.OfFunctorialResolutions | ∀ {C₁ : Type u_1} {C₂ : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} [Φ.functor.Full]
[Φ.functor.Faithful], ((CategoryTheory... | null | false |
Equiv.Perm.cycleFactorsFinset_eq_finset | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {σ : Equiv.Perm α} {s : Finset (Equiv.Perm α)},
σ.cycleFactorsFinset = s ↔ (∀ f ∈ s, f.IsCycle) ∧ ∃ (h : (↑s).Pairwise Equiv.Perm.Disjoint), s.noncommProd id ⋯ = σ | null | true |
Finset.min.eq_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α), s.min = s.inf WithTop.some | null | true |
CategoryTheory.Limits.pullback.instIsIsoDiagonalOfMono | 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.HasPullback f f] [CategoryTheory.Mono f],
CategoryTheory.IsIso (CategoryTheory.Limits.pullback.diagonal f) | null | true |
AddSubsemigroup.closure.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Add M] (s : Set M), AddSubsemigroup.closure s = sInf {S | s ⊆ ↑S} | null | true |
CategoryTheory.NonemptyParallelPairPresentationAux.presentation._proof_1 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
(f g : A ⟶ B) (P₁ : CategoryTheory.Limits.IndObjectPresentation A)
(P₂ : CategoryTheory.Limits.IndObjectPresentation B),
CategoryTheory.IsFiltered
(CategoryTheory.Comma
((P₁.toCostructuredArrow.c... | null | false |
Aesop.RuleStats.successful | Aesop.Stats.Basic | Aesop.RuleStats → Bool | null | true |
InnerProductSpace.ringOfCoalgebra | Mathlib.Analysis.InnerProductSpace.Coalgebra | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] → [FiniteDimensional 𝕜 E] → [Coalgebra 𝕜 E] → Ring E | A finite-dimensional inner product space with a coalgebra structure induces a ring structure,
where multiplication is given by `x * y = (adjoint comul) (x ⊗ₜ y)` and
`1 = (adjoint counit) (1 : 𝕜)`.
See note [reducible non-instances]. | true |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_map_piCurry_symm._simp_1_2 | Mathlib.Probability.ProductMeasure | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | null | false |
Aesop.EMap.casesOn | Aesop.EMap | {α : Type u_1} →
{motive : Aesop.EMap α → Sort u} →
(t : Aesop.EMap α) →
((rep : Lean.PArray (Option (Lean.Expr × α))) →
(idx : Lean.Meta.DiscrTree ℕ) → motive { rep := rep, idx := idx }) →
motive t | null | false |
_private.Mathlib.Topology.Constructions.0.isOpenMap_sigma._simp_1_2 | Mathlib.Topology.Constructions | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop},
(∀ (x : (a : α) × β a), p x) = ∀ (a : α) (b : β a), p ⟨a, b⟩ | null | false |
AddSemigrp.ofHom_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : Type u} [inst : AddSemigroup X], AddSemigrp.ofHom (AddHom.id X) = CategoryTheory.CategoryStruct.id ↧X | null | true |
Filter.lift'_inf_principal_eq | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {s : Set β},
f.lift' h ⊓ Filter.principal s = f.lift' fun t => h t ∩ s | null | true |
ContinuousMapZero.toContinuousMapHom | Mathlib.Topology.ContinuousMap.ContinuousMapZero | {X : Type u_1} →
{R : Type u_2} →
[inst : Zero X] →
[inst_1 : TopologicalSpace X] →
[inst_2 : TopologicalSpace R] →
[inst_3 : CommSemiring R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : StarRing R] → [inst_6 : ContinuousStar R] → ContinuousMapZero X R →⋆ₙₐ[R]... | The coercion `C(X, R)₀ → C(X, R)` bundled as a non-unital star algebra homomorphism. | true |
MonadState.set.eq_def | Std.Do.Triple.SpecLemmas | ∀ {σ : Type u} (m : Type u → Type v) [self : MonadState σ m], MonadState.set = self.2 | null | true |
_private.Mathlib.Geometry.Euclidean.Triangle.0.EuclideanGeometry.sin_angle_div_dist_eq_sin_angle_div_dist._simp_1_3 | Mathlib.Geometry.Euclidean.Triangle | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.mem.match_1.eq_1 | Mathlib.Data.Ordmap.Ordset | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | null | true |
Std.TreeMap.getKeyD_maxKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{he : t.isEmpty = false} {fallback : α}, t.getKeyD (t.maxKey he) fallback = t.maxKey he | null | true |
AddMonCat.HasLimits.limitConeIsLimit._proof_1 | Mathlib.Algebra.Category.MonCat.Limits | (CategoryTheory.forget AddMonCat).Faithful | null | false |
_private.Mathlib.RingTheory.DividedPowers.Basic.0.DividedPowers.dpow_sum'._simp_1_1 | Mathlib.RingTheory.DividedPowers.Basic | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
MonadCont.Label._sizeOf_1 | Mathlib.Control.Monad.Cont | {α : Type w} →
{m : Type u → Type v} →
{β : Type u} → [SizeOf α] → [(a : Type u) → SizeOf (m a)] → [SizeOf β] → MonadCont.Label α m β → ℕ | null | false |
CuspForm.copy._proof_1 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} {Γ' : Subgroup (GL (Fin 2) ℝ)} (f : CuspForm Γ k) (f' : UpperHalfPlane → ℂ)
(h : f' = ⇑f) (hΓ : Γ' = Γ), ⇑f = f' → MDiff ⇑f.toSlashInvariantForm → MDiff ⇑{ toFun := f', slash_action_eq' := ⋯ } | null | false |
Mathlib.Meta.NormNum.IsNat.rpow_eq_pow | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {b : ℝ} {n : ℕ}, Mathlib.Meta.NormNum.IsNat b n → ∀ (a : ℝ), a ^ b = a ^ n | null | true |
CategoryTheory.MonoidalCoherence.whiskerLeft | Mathlib.Tactic.CategoryTheory.MonoidalComp | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(X Y Z : C) →
[CategoryTheory.MonoidalCoherence Y Z] →
CategoryTheory.MonoidalCoherence (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)
(CategoryTheory.MonoidalCatego... | null | true |
_private.Init.Data.List.Find.0.List.findIdx?_flatten._simp_1_1 | Init.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (l.any p = true) = ∃ x ∈ l, p x = true | null | false |
Int.Internal.Linear.cooper_dvd_left_split_dvd2 | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (p₁ p₂ p₃ : Int.Internal.Linear.Poly) (d : ℤ) (k : ℕ) (d' : ℤ)
(p' : Int.Internal.Linear.Poly),
Int.Internal.Linear.cooper_dvd_left_split ctx p₁ p₂ p₃ d k →
Int.Internal.Linear.cooper_dvd_left_split_dvd2_cert p₁ p₃ d k d' p' = true →
d' ∣ Int.Internal.Linear.Poly.deno... | null | true |
ContinuousLinearMap.isBigOWith_sub | Mathlib.Analysis.Normed.Operator.Asymptotics | ∀ {𝕜 : 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 |
ENNReal.ofReal_lt_coe_iff | Mathlib.Basic.ENNReal.Real | ∀ {a : ℝ} {b : NNReal}, 0 ≤ a → (ENNReal.ofReal a < ↑b ↔ a < ↑b) | null | true |
AddValuation.IsEquiv.comap | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} {Γ'₀ : Type u_5} [inst : LinearOrderedAddCommMonoidWithTop Γ₀]
[inst_1 : LinearOrderedAddCommMonoidWithTop Γ'₀] [inst_2 : Ring R] {v₁ : AddValuation R Γ₀} {v₂ : AddValuation R Γ'₀}
{S : Type u_7} [inst_3 : Ring S] (f : S →+* R),
v₁.IsEquiv v₂ → (AddValuation.comap f v₁).IsEquiv (A... | `comap` preserves equivalence. | true |
List.prod_hom₂ | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {ι : Type u_1} {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P]
(l : List ι) (f : M → N → P),
(∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d) →
f 1 1 = 1 →
∀ (f₁ : ι → M) (f₂ : ι → N),
(List.map (fun i => f (f₁ i) (f₂ i)) l).prod =... | null | true |
Set.Disjoint.set_pi | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t₁ t₂ : (i : ι) → Set (α i)} {i : ι},
i ∈ s → Disjoint (t₁ i) (t₂ i) → Disjoint (s.pi t₁) (s.pi t₂) | null | true |
_private.Mathlib.RingTheory.Valuation.ValuationSubring.0.ValuationSubring.image_maximalIdeal._simp_1_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
CategoryTheory.Bicategory.Adj.whiskerRight_τl | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : CategoryTheory.Bicategory.Adj B} {f g : a ⟶ b} (x : f ⟶ g)
(β : b ⟶ c), (CategoryTheory.Bicategory.whiskerRight x β).τl = CategoryTheory.Bicategory.whiskerRight x.τl β.l | null | true |
FreeAbelianGroup.ring._proof_11 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1) [inst : Monoid α] (a : FreeAbelianGroup α), 0 * a = 0 | null | false |
Lean.Meta.Sym.ProofInstArgInfo.noConfusionType | Lean.Meta.Sym.SymM | Sort u → Lean.Meta.Sym.ProofInstArgInfo → Lean.Meta.Sym.ProofInstArgInfo → Sort u | null | false |
CategoryTheory.AddMonObj.ofRepresentableBy._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) (F : CategoryTheory.Functor Cᵒᵖ AddMonCat) (α : (F.comp (CategoryTheory.forget AddMonCat)).RepresentableBy X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.... | null | false |
Finset.count_coe_finsuppAntidiagEquiv_apply | Mathlib.Algebra.Order.Antidiag.FinsuppEquiv | ∀ {ι : Type u_1} [inst : DecidableEq ι] {s : Finset ι} (n : ℕ) (f : ↥(s.finsuppAntidiag n)) (a : ↥s),
Multiset.count a ↑((s.finsuppAntidiagEquiv n) f) = ↑f ↑a | null | true |
WeierstrassCurve.Affine.Point.toClass | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {F : Type u} →
[inst : Field F] →
{W : WeierstrassCurve.Affine F} → [inst_1 : DecidableEq F] → W.Point →+ Additive (ClassGroup W.CoordinateRing) | The group homomorphism mapping a nonsingular affine point `(x, y)` of a Weierstrass curve `W` to
the class of the non-zero fractional ideal `⟨X - x, Y - y⟩` in the ideal class group of `F[W]`. | true |
Algebra.Generators.naive._proof_3 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} [inst : CommRing R] {σ : Type u_2} {I : Ideal (MvPolynomial σ R)}, I.IsTwoSided | null | false |
Lean.Widget.InteractiveHypothesisBundle.isRemoved? | Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveHypothesisBundle → Option Bool | If true, the hypothesis will be removed in the next tactic state.
Only present in tactic-mode goals. | true |
InfClosed.prod | Mathlib.Order.SupClosed | ∀ {α : Type u_3} {β : Type u_4} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {s : Set α} {t : Set β},
InfClosed s → InfClosed t → InfClosed (s ×ˢ t) | null | true |
Bimod.regular_actRight | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(A : CategoryTheory.Mon C), (Bimod.regular A).actRight = CategoryTheory.MonObj.mul | null | true |
Std.DTreeMap.Internal.Impl.minKey_le_of_contains | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} (hc : Std.DTreeMap.Internal.Impl.contains k t = true), (compare (t.minKey ⋯) k).isLE = true | null | true |
MeasureTheory.indicatorConstLp.eq_1 | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
{s : Set α} (p : ENNReal) (hs : MeasurableSet s) (hμs : μ s ≠ ⊤) (c : E),
MeasureTheory.indicatorConstLp p hs hμs c = MeasureTheory.MemLp.toLp (s.indicator fun x => c) ⋯ | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_emod._proof_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℕ), ¬0 ≤ ↑a + 1 → False | null | false |
CategoryTheory.isCofilteredOrEmpty_of_semilatticeInf | Mathlib.CategoryTheory.Filtered.Basic | ∀ (α : Type u) [inst : SemilatticeInf α], CategoryTheory.IsCofilteredOrEmpty α | null | true |
CommGrpCat.instConcreteCategoryMonoidHomCarrier._proof_3 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X : CommGrpCat} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
CategoryTheory.CommGrp.instCategory._aux_3 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (X : CategoryTheory.CommGrp C) → X ⟶ X | null | false |
CauSeq.Completion.instInhabitedCauchy | Mathlib.Algebra.Order.CauSeq.Completion | {α : Type u_1} →
[inst : Field α] →
[inst_1 : LinearOrder α] →
[inst_2 : IsStrictOrderedRing α] →
{β : Type u_2} →
[inst_3 : Ring β] → {abv : β → α} → [inst_4 : IsAbsoluteValue abv] → Inhabited (CauSeq.Completion.Cauchy abv) | null | true |
CategoryTheory.Grpd.delabOf | Mathlib.CategoryTheory.Groupoid.Grpd.Basic | Lean.PrettyPrinter.Delaborator.Delab | This prints `CategoryTheory.Grpd.of X` as `↧X`. | true |
Lean.Meta.Grind.EMatchTheoremKind.bwd.noConfusion | Lean.Meta.Tactic.Grind.Extension | {P : Sort u} →
{gen gen' : Bool} →
Lean.Meta.Grind.EMatchTheoremKind.bwd gen = Lean.Meta.Grind.EMatchTheoremKind.bwd gen' → (gen = gen' → P) → P | null | false |
ContinuousLinearMap.bddAbove_rayleighQuotient | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E), BddAbove (Set.range fun x => |T.rayleighQuotient x|) | null | true |
HomotopicalAlgebra.PathObject.IsVeryGood.rec | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : C} →
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] →
{P : HomotopicalAlgebra.PathObject A} →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct A A] →
[inst_3 : HomotopicalAlgebra.CategoryWithFibration... | null | false |
_private.Std.Http.Data.Chunk.0.Std.Http.Chunk.instDecidableEqExtensionName.decEq._proof_3 | Std.Http.Data.Chunk | ∀ (a : String) (a_1 : Std.Http.Chunk.IsValidExtensionName a) (b : String) (b_1 : Std.Http.Chunk.IsValidExtensionName b),
¬a = b → { value := a, isValidExtensionName := a_1 } = { value := b, isValidExtensionName := b_1 } → False | null | false |
UniformSpaceCat._sizeOf_inst | Mathlib.Topology.Category.UniformSpace | SizeOf UniformSpaceCat | null | false |
Cardinal.preAleph_le_aleph | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o : Ordinal.{u_1}), Cardinal.preAleph o ≤ Cardinal.aleph o | null | true |
WeierstrassCurve.Projective.X_eq_of_equiv | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] {P Q : Fin 3 → R}, P ≈ Q → P 0 * Q 2 = Q 0 * P 2 | null | true |
_private.Mathlib.LinearAlgebra.Multilinear.DFinsupp.0.MultilinearMap.dfinsuppFamily._simp_3 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
Lean.Compiler.LCNF.FixedParams.State.noConfusionType | Lean.Compiler.LCNF.FixedParams | Sort u → Lean.Compiler.LCNF.FixedParams.State → Lean.Compiler.LCNF.FixedParams.State → Sort u | null | false |
Std.ExtDHashMap.eq_empty_iff_size_eq_zero | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m = ∅ ↔ m.size = 0 | null | true |
Sum.getRight | Init.Data.Sum.Basic | {α : Type u_1} → {β : Type u_2} → (ab : α ⊕ β) → ab.isRight = true → β | Retrieves the contents from a sum known to be `inr`. | true |
CategoryTheory.preadditiveCoyonedaObj._proof_2 | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (X X_1 : C),
ModuleCat.ofHom
{ toFun := fun g => CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.id X_1), map_add' := ⋯,
map_smul' := ⋯ } =
CategoryTheory.CategoryStruct.id ↧(X ... | null | false |
_private.Mathlib.Algebra.MvPolynomial.Division.0.MvPolynomial.X_dvd_monomial._simp_1_3 | Mathlib.Algebra.MvPolynomial.Division | ∀ {n : ℕ}, (1 ≤ n) = (n ≠ 0) | null | false |
CategoryTheory.Localization.Preadditive.neg'_add'_self | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {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] [inst_2 : CategoryTheory.Preadditive C]
{L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
[inst_4 : W.HasLeftCalculusOfFractions] {X Y ... | null | true |
MonoidAlgebra.mapDomainAlgHom._proof_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_4) (A : Type u_1) {M : Type u_3} {N : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Monoid M] [inst_4 : Monoid N] (f : M →* N) (r : R),
(↑↑(MonoidAlgebra.mapDomainRingHom A f)).toFun ((algebraMap R (MonoidAlgebra A M)) r) =
(algebraMap R (MonoidAlgebra A ... | null | false |
Real.BohrMollerup.logGammaSeq | Mathlib.Analysis.SpecialFunctions.Gamma.BohrMollerup | ℝ → ℕ → ℝ | The function `n ↦ x log n + log n! - (log x + ... + log (x + n))`, which we will show tends to
`log (Gamma x)` as `n → ∞`. | true |
MeasureTheory.AEEqFun.compMeasurable_mk | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] [inst_3 : MeasurableSpace β]
[inst_4 : TopologicalSpace.PseudoMetrizableSpace β] [inst_5 : BorelSpace β] [inst_6 : MeasurableSpace γ]
[inst_7 : Topolo... | null | true |
Std.Internal.List.containsKey_modifyKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] (k k' : α) (f : β k → β k)
(l : List ((a : α) × β a)),
Std.Internal.List.containsKey k' (Std.Internal.List.modifyKey k f l) = Std.Internal.List.containsKey k' l | null | true |
Std.ExtHashMap.getKeyD_diff_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k fallback : α}, k ∉ m₁ → (m₁ \ m₂).getKeyD k fallback = fallback | null | true |
Subsemigroup.closure_univ | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M], Subsemigroup.closure Set.univ = ⊤ | null | true |
String.Slice.beq_eq_decide | Init.Data.String.Lemmas.Slice | ∀ {s t : String.Slice}, (s == t) = decide (s.copy = t.copy) | null | true |
analyticAt_clog | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | ∀ {z : ℂ}, z ∈ Complex.slitPlane → AnalyticAt ℂ Complex.log z | `log` is analytic away from nonpositive reals | true |
_private.Lean.Elab.ConfigEval.Types.0.Lean.Elab.ConfigEval.ReflectConfigItems | Lean.Elab.ConfigEval.Types | Type → Type | null | true |
Rat.sub_den_dvd | Mathlib.Data.Rat.Lemmas | ∀ (q₁ q₂ : ℚ), (q₁ - q₂).den ∣ q₁.den * q₂.den | null | true |
CategoryTheory.SimplicialObject.Augmented.w_app_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject.Augmented C} (f : X ⟶ Y)
(n : SimplexCategoryᵒᵖ) {Z : C} (h : Y.right ⟶ Z),
CategoryTheory.CategoryStruct.comp (f.left.app n) (CategoryTheory.CategoryStruct.comp (Y.hom.app n) h) =
CategoryTheory.CategoryStruct.comp ... | null | true |
CategoryTheory.Mon.ofHom_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A B : C}
[inst_2 : CategoryTheory.MonObj A] [inst_3 : CategoryTheory.MonObj B] (f : A ⟶ B)
[inst_4 : CategoryTheory.IsMonHom f], (CategoryTheory.Mon.ofHom f).hom = f | null | true |
Std.Time.Fraction.ctorElimType | Std.Time.Format.Modifier | {motive : Std.Time.Fraction → Sort u} → ℕ → Sort (max 1 u) | null | false |
MulAlgebraNorm._sizeOf_1 | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
{inst : SeminormedCommRing R} →
{S : Type u_2} → {inst_1 : Ring S} → {inst_2 : Algebra R S} → [SizeOf R] → [SizeOf S] → MulAlgebraNorm R S → ℕ | null | false |
List.Subperm.cons_right | Batteries.Data.List.Perm | ∀ {α : Type u_1} {l l' : List α} (x : α), l.Subperm l' → l.Subperm (x :: l') | null | true |
Lean.Meta.Grind.EMatch.State.matchEqNames._default | Lean.Meta.Tactic.Grind.Types | Lean.PHashSet Lean.Name | null | false |
PowerSeries.zero_weierstrassDiv | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] [inst_1 : IsLocalRing A] (g : PowerSeries A)
[inst_2 : IsAdicComplete (IsLocalRing.maximalIdeal A) A], 0 /ʷ g = 0 | **Alias** of `PowerSeries.weierstrassDiv_zero_left`. | true |
Std.DHashMap.Internal.Raw₀.isEmpty_keys | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → (↑m).keys.isEmpty = (↑m).isEmpty | null | true |
_private.Mathlib.Order.Disjointed.0.partialSups_disjointed._simp_1_1 | Mathlib.Order.Disjointed | ∀ {i : ℕ}, (i ≤ 0) = (i = 0) | null | false |
Function.locallyFinsuppWithin.toClosedBall_divisor | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {r : ℝ} {f : ℂ → ℂ},
Meromorphic f →
MeromorphicOn.divisor f (Metric.closedBall 0 |r|) =
(Function.locallyFinsuppWithin.toClosedBall r) (MeromorphicOn.divisor f Set.univ) | null | true |
ModuleCat.instPreservesFiniteColimitsLocalizationLocalizedModuleFunctor | Mathlib.Algebra.Category.ModuleCat.Localization | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Small.{v, u} R] (S : Submonoid R),
CategoryTheory.Limits.PreservesFiniteColimits (ModuleCat.localizedModuleFunctor S) | null | true |
Right.inv_le_one_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulRightMono α] {a : α}, a⁻¹ ≤ 1 ↔ 1 ≤ a | Uses `right` co(ntra)variant. | true |
LinearMap.BilinForm.Isometry.map_app' | Mathlib.LinearAlgebra.BilinearForm.Isometry | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {B₁ : LinearMap.BilinForm R M₁}
{B₂ : LinearMap.BilinForm R M₂} (self : B₁ →bᵢ B₂) (m m' : M₁), (B₂ (self.toFun m)) (self.toFun m') = (B₁ m) ... | The bilinear forms agree across the map. | true |
CategoryTheory.Triangulated.TStructure.natTransTruncLTOfLE_ι_app_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
_private.Mathlib.Topology.ShrinkingLemma.0.exists_iUnion_eq_closed_subset.match_1_1 | Mathlib.Topology.ShrinkingLemma | ∀ {ι : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {u : ι → Set X}
(motive : (∃ v, Set.univ ⊆ Set.iUnion v ∧ (∀ (i : ι), IsClosed (v i)) ∧ ∀ (i : ι), v i ⊆ u i) → Prop)
(x : ∃ v, Set.univ ⊆ Set.iUnion v ∧ (∀ (i : ι), IsClosed (v i)) ∧ ∀ (i : ι), v i ⊆ u i),
(∀ (v : ι → Set X) (vU : Set.univ ⊆ Set.iUnion ... | null | false |
CategoryTheory.Over.instHasFiniteCoproducts | Mathlib.CategoryTheory.Limits.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} [CategoryTheory.Limits.HasFiniteCoproducts C],
CategoryTheory.Limits.HasFiniteCoproducts (CategoryTheory.Over X) | null | true |
Finpartition.parts_top_subset | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] (a : α) [inst_2 : Decidable (a = ⊥)], ⊤.parts ⊆ {a} | null | true |
CategoryTheory.Span.id | Mathlib.CategoryTheory.Bicategory.Span.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{Wₗ Wᵣ : CategoryTheory.MorphismProperty C} →
[Wₗ.ContainsIdentities] → [Wᵣ.ContainsIdentities] → (c : C) → CategoryTheory.Span Wₗ Wᵣ c c | The identity span, where both legs are identity morphisms. | true |
CochainComplex.triangleOfDegreewiseSplit | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) →
((n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting) →
CategoryTheory.Pretriangulated.Triangle (Cocha... | The triangle in `CochainComplex C ℤ` attached to a degreewise split short exact sequence
of cochain complexes. | true |
_private.Init.Data.SInt.Lemmas.0.Int8.toInt32_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x < y) = (x.toInt < y.toInt) | null | false |
Algebra.TensorProduct.comm._proof_2 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R R A | null | false |
MeasureTheory.Measure.haar.addPrehaar_self | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G]
{K₀ : TopologicalSpace.PositiveCompacts G} {U : Set G},
(interior U).Nonempty → MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₀.toCompacts = 1 | null | true |
CategoryTheory.Arrow.homMk_right | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (u : f.left ⟶ g.left)
(v : f.right ⟶ g.right)
(w :
autoParam (CategoryTheory.CategoryStruct.comp u g.hom = CategoryTheory.CategoryStruct.comp f.hom v)
CategoryTheory.Arrow.homMk._auto_1),
(CategoryTheory.Arrow.homMk ... | null | true |
Std.Time.Modifier.u.inj | Std.Time.Format.Modifier | ∀ {presentation presentation_1 : Std.Time.Year},
Std.Time.Modifier.u presentation = Std.Time.Modifier.u presentation_1 → presentation = presentation_1 | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_7.splitter | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(l : Std.DTreeMap.Internal.Impl α β) →
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size r.size → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(hrb : r.Balanced) ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.