name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousNeg.mk._flat_ctor | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : Neg G], (Continuous fun a => -a) → ContinuousNeg G | null | false |
PrimrecPred.comp | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : β → Prop} {f : α → β},
PrimrecPred p → Primrec f → PrimrecPred fun a => p (f a) | null | true |
PosNum.lor._unsafe_rec | Mathlib.Data.Num.Bitwise | PosNum → PosNum → PosNum | null | false |
OrderDual.instAddCancelCommMonoid | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [AddCancelCommMonoid α] → AddCancelCommMonoid αᵒᵈ | null | true |
Std.DTreeMap.Internal.Zipper.prependMapGE._unsafe_rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[Ord α] → Std.DTreeMap.Internal.Impl α β → α → Std.DTreeMap.Internal.Zipper α β → Std.DTreeMap.Internal.Zipper α β | null | false |
CochainComplex.mappingCocone.lift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) {M : CochainComplex C ℤ} (α : M ⟶ K)
(β : CochainComplex.HomComplex.Cochain M L (-1)),
CochainComplex.HomComplex.δ (-1) 0 β +
CochainComplex.HomComplex.Cochain.ofHo... | null | false |
IsSMulRegular.of_mul_eq_one | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} {M : Type u_3} {a b : R} [inst : Monoid R] [inst_1 : MulAction R M], a * b = 1 → IsSMulRegular M b | An element of `R` admitting a left inverse is `M`-regular. | true |
List.Interleaves.nil_nil._simp_1 | Mathlib.Data.List.Interleave | ∀ {α : Type u_1} {r : α → α → Prop}, List.Interleaves r [] [] = True | null | false |
frequently_nhds_iff | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {p : X → Prop},
(∃ᶠ (y : X) in nhds x, p y) ↔ ∀ (U : Set X), x ∈ U → IsOpen U → ∃ y ∈ U, p y | null | true |
Lean.ImportState.ctorIdx | Lean.Environment | Lean.ImportState → ℕ | null | false |
TensorProduct.AlgebraTensorModule.map_smul_right | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : ... | null | true |
Num.gcdAux.eq_1 | Mathlib.Data.Num.ZNum | ∀ (x x_1 : Num), Num.gcdAux 0 x x_1 = x_1 | null | true |
Submonoid.center_prod | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : MulOneClass M] {N : Type u_2} [inst_1 : MulOneClass N],
Submonoid.center (M × N) = (Submonoid.center M).prod (Submonoid.center N) | null | true |
_private.Mathlib.Analysis.Asymptotics.Lemmas.0.Asymptotics.IsLittleO.tendsto_inv_smul_nhds_zero._simp_1_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a : α), ‖a‖⁻¹ = ‖a⁻¹‖ | null | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.dist_eq_one_of_head._simp_1_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (Nat.find h = 0) = p 0 | null | false |
CategoryTheory.Limits.cospanCompIso_hom_app_right | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z),
(CategoryTheory.Limits.cospanCompIso F f g).hom.app CategoryTheory.Limits.WalkingCospan.right =
CategoryTheory.CategoryStruct... | null | true |
CategoryTheory.Triangulated.SpectralObject.instCategory._proof_7 | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Addit... | null | false |
_private.Mathlib.Algebra.GroupWithZero.WithZero.0.WithZero.monoidWithZeroHom_ext.match_1_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} (motive : WithZero α → Prop) (x : WithZero α),
(∀ (_ : Unit), motive none) → (∀ (g : α), motive (some g)) → motive x | null | false |
stdOrthonormalBasis | Mathlib.Analysis.InnerProductSpace.PiL2 | (𝕜 : Type u_7) →
[inst : RCLike 𝕜] →
(E : Type u_8) →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] → [FiniteDimensional 𝕜 E] → OrthonormalBasis (Fin (Module.finrank 𝕜 E)) 𝕜 E | A finite-dimensional `InnerProductSpace` has an orthonormal basis. | true |
AlgebraicGeometry.instModuleObjOppositeOpensCarrierTopObjFunctorTypeIsSheafGrothendieckTopologyStructureSheafInType_1._proof_3 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(U : (TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))ᵒᵖ)
(x y : (AlgebraicGeometry.structureSheafInType R R).obj.obj U)
(b : (AlgebraicGeometry.structureSheafInType R M).obj.obj U), (x * y) • b = x • y • b | null | false |
MulAut.characteristic._proof_17 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : H.Characteristic],
{ toFun := fun h => ⟨1 ↑h, ⋯⟩, invFun := fun h => ⟨(MulEquiv.symm 1) ↑h, ⋯⟩, left_inv := ⋯, right_inv := ⋯,
map_mul' := ⋯ } =
{ toFun := fun h => ⟨1 ↑h, ⋯⟩, invFun := fun h => ⟨(MulEquiv.symm 1) ↑h, ⋯⟩, left_inv := ⋯, right_inv ... | null | false |
CategoryTheory.Limits.FormalCoproduct.Hom.fromIncl_asSigma | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {Y : CategoryTheory.Limits.FormalCoproduct C}
(f : (CategoryTheory.Limits.FormalCoproduct.incl C).obj X ⟶ Y),
CategoryTheory.Limits.FormalCoproduct.Hom.fromIncl (CategoryTheory.Limits.FormalCoproduct.Hom.asSigma f).fst
(CategoryTheory.Limits.For... | null | true |
Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKey! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α], t.WF → ∀ {a : α}, a ∈ t → t.getKey? a = some (t.getKey! a) | null | true |
Submodule.tensorSpanEquivSpan | Mathlib.LinearAlgebra.Span.TensorProduct | (R : Type u_1) →
(A : Type u_2) →
{M : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] →
[inst_2 : Algebra R A] →
[inst_3 : AddCommMonoid M] →
[inst_4 : Module R M] →
[inst_5 : Module A M] →
[IsScalarTower R A M] →... | If `A` is a flat epi `R`-algebra and `s` is a subset of an `A`-module `M` then the natural
surjection from `A ⊗[R] span R s` to `span A s` is an equivalence. | true |
Dvd.intro | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α} (c : α), a * c = b → a ∣ b | null | true |
CategoryTheory.Functor.IsEventuallyConstantTo.cone | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
{F : CategoryTheory.Functor J C} →
{i₀ : J} → F.IsEventuallyConstantTo i₀ → [CategoryTheory.IsCofiltered J] → CategoryTheory.Limits.Cone F | Given `h : F.IsEventuallyConstantTo i₀`, this is the (limit) cone for `F` whose
point is `F.obj i₀`. | true |
mem_uniformity_isClosed | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α] {s : SetRel α α}, s ∈ uniformity α → ∃ t ∈ uniformity α, IsClosed t ∧ t ⊆ s | null | true |
CategoryTheory.LocallyDiscrete.mk.inj | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ {C : Type u} {as as_1 : C}, { as := as } = { as := as_1 } → as = as_1 | null | true |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.get._proof_2 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] (m : Std.ExtDHashMap α β),
∀ a ∈ m, ∀ (m_1 m' : Std.DHashMap α β), m = Std.ExtDHashMap.mk m_1 → m_1.Equiv m' → a ∈ m' | null | false |
RingCat.Colimits.Prequotient._sizeOf_1 | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
{F : CategoryTheory.Functor J RingCat} → [SizeOf J] → RingCat.Colimits.Prequotient F → ℕ | null | false |
ContinuousLinearMap.continuousConstSMul | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_4}
{F : Type u_5} [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜₂ F]
[inst_6 : TopologicalSpace E] {M : Type u_7} [inst_7 : Monoid M] [inst_8 : Distr... | null | true |
LieIdeal.map_sup_ker_eq_map | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L},
LieIdeal.map f (I ⊔ f.ker) = LieIdeal.map f I | null | true |
SimpleGraph.Copy.isoSubgraphMap._simp_4 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_1}, (∀ (a : α), True) = True | null | false |
Ideal.setOfPred_isPrincipal_wellFoundedOn_gt | Mathlib.RingTheory.UniqueFactorizationDomain.Ideal | ∀ {α : Type u_1} [inst : CommSemiring α] [WfDvdMonoid α] [IsDomain α],
{I | Submodule.IsPrincipal I}.WellFoundedOn fun x1 x2 => x1 > x2 | The ascending chain condition on principal ideals holds in a `WfDvdMonoid` domain. | true |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.canonicalDecomposition_aux₁.match_1_1 | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {R : ℝ} (a b : ℂ) (motive : a ∈ Metric.ball 0 R ∧ b ∈ Metric.ball 0 R → Prop)
(x : a ∈ Metric.ball 0 R ∧ b ∈ Metric.ball 0 R),
(∀ (h₂a : a ∈ Metric.ball 0 R) (h₂b : b ∈ Metric.ball 0 R), motive ⋯) → motive x | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.Poly.isUnsatEq.match_1.eq_1 | Init.Data.Int.Linear | ∀ (motive : Int.Internal.Linear.Poly → Sort u_1) (k : ℤ) (h_1 : (k : ℤ) → motive (Int.Internal.Linear.Poly.num k))
(h_2 : (x : Int.Internal.Linear.Poly) → motive x),
(match Int.Internal.Linear.Poly.num k with
| Int.Internal.Linear.Poly.num k => h_1 k
| x => h_2 x) =
h_1 k | null | true |
Lean.Lsp.instHashableResolvableCompletionItemData.hash | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ResolvableCompletionItemData → UInt64 | null | true |
Lean.Compiler.LCNF.LambdaLifting.Context.allowEtaContraction | Lean.Compiler.LCNF.LambdaLifting | Lean.Compiler.LCNF.LambdaLifting.Context → Bool | Allow for eta contraction instead of lifting to a lambda if possible.
| true |
MeasureTheory.ofReal_setAverage | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f : α → ℝ},
MeasureTheory.IntegrableOn f s μ →
0 ≤ᵐ[μ.restrict s] f → ENNReal.ofReal (⨍ (x : α) in s, f x ∂μ) = (∫⁻ (x : α) in s, ENNReal.ofReal (f x) ∂μ) / μ s | null | true |
ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl._proof_4 | Mathlib.Analysis.Normed.Module.Complemented | ∀ {𝕜 : Type u_4} {E : Type u_1} {F : Type u_3} {G : Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (f : E →L[𝕜] F) (g : E →L[𝕜] G),
... | null | false |
Lean.Elab.InlayHintInfo.label | Lean.Elab.InfoTree.InlayHints | Lean.Elab.InlayHintInfo → Lean.Elab.InlayHintLabel | null | true |
Set.indicator_pi_one_apply | Mathlib.Algebra.BigOperators.GroupWithZero.Finset | ∀ {ι : Type u_1} {M₀ : Type u_4} {α : ι → Type u_5} [inst : CommMonoidWithZero M₀] (s : Finset ι)
(t : (i : ι) → Set (α i)) (f : (i : ι) → α i), ((↑s).pi t).indicator 1 f = ∏ i ∈ s, (t i).indicator 1 (f i) | null | true |
Nat.eq_zero_of_two_mul_le | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, 2 * n ≤ n → n = 0 | null | true |
CategoryTheory.Abelian.Ext.hom | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
{X Y : C} →
[inst_3 : HasDerivedCategory C] →
{a : ℕ} →
CategoryTheory.Abelian.Ext X Y a →
CategoryTheory.ShiftedH... | The morphism in the derived category which corresponds to an element in `Ext X Y a`. | true |
Std.DTreeMap.Internal.Impl.maxKey!.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Inhabited α] (motive : Std.DTreeMap.Internal.Impl α β → α → Prop),
motive Std.DTreeMap.Internal.Impl.leaf
(panicWithPosWithDecl "Std.Data.DTreeMap.Internal.Queries" "Std.DTreeMap.Internal.Impl.maxKey!" 436 13
"Map is empty") →
(∀ (size : ℕ) (k : α) (v : β k) (... | null | true |
Std.CancellationContext.token | Std.Sync.CancellationContext | Std.CancellationContext → Std.CancellationToken | null | true |
Equiv.Perm.disjoint_iff_eq_or_eq | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {f g : Equiv.Perm α}, f.Disjoint g ↔ ∀ (x : α), f x = x ∨ g x = x | null | true |
UniformConvergenceCLM.instAddCommGroup._proof_16 | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : 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 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | null | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs.0.Tactic.ComputeAsymptotics.MultiseriesExpansion.Approximates.coind._proof_1_7 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : Tactic.ComputeAsymptotics.Basis} (a : ℝ → ℝ) (a_1 : List (ℝ → ℝ)),
a = basis_hd ∧ a_1 = basis_tl → a :: a_1 = basis_hd :: basis_tl | null | false |
ImportGraph.Lake.BasePackage.wsIdx | ImportGraph.WorkspaceModel.Base | ImportGraph.Lake.BasePackage → ℕ | Lake's index for the package (`Package.wsIdx`) Together with `baseName`, this disambiguates
packages. | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_11 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (res : Lean.Name) (acc : String) (ucount : ℕ) (hp₀ : ¬p₀ = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x ... | null | false |
ProbabilityTheory.Kernel.integral_congr_ae₂ | Mathlib.Probability.Kernel.Integral | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
{E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f g : α → β → E}
{μ : MeasureTheory.Measure α},
(∀ᵐ (a : α) ∂μ, f a =ᵐ[κ a] g a) → ∫ (a : α), ∫ (b : β), f a b ∂κ a ∂μ = ∫ (... | null | true |
CategoryTheory.ComposableArrows.homMk₄_app_four | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 4}
(app₀ : f.obj' 0 _proof_369✝ ⟶ g.obj' 0 _proof_369✝)
(app₁ :
f.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₄₁₂._proof_2 ⟶
g.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₄₁₂._proof_2)
(ap... | null | true |
Real.arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ℝ → ℝ | Inverse of the `cos` function, returns values in the range `0 ≤ arccos x` and `arccos x ≤ π`.
It defaults to `π` on `(-∞, -1)` and to `0` to `(1, ∞)`. | true |
Subring.coe_intCast | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) (n : ℤ), ↑↑n = ↑n | null | true |
MeasureTheory.self_subset_generateSetAlgebra | Mathlib.MeasureTheory.SetAlgebra | ∀ {α : Type u_1} {𝒜 : Set (Set α)}, 𝒜 ⊆ MeasureTheory.generateSetAlgebra 𝒜 | The algebra of sets generated by `𝒜` contains `𝒜`. | true |
NormedField.completeSpace_iff_isComplete_closedBall | Mathlib.Analysis.Normed.Field.Lemmas | ∀ {K : Type u_4} [inst : NormedField K], CompleteSpace K ↔ IsComplete (Metric.closedBall 0 1) | null | true |
AffineEquiv.ext_on | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {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₁] {V₂ : Type u_8} {P₂ : Type u_9} [inst_4 : AddCommGroup V₂] [inst_5 : Module k V₂]
[inst_6 : AddTorsor V₂ P₂] {s : Set P₁},
affineSpan k s = ⊤ → ∀ (T₁ T₂ : P₁ ≃ᵃ[k] P₂), Set... | If two affine equivalences agree on a set that spans the entire space, then they are equal. | true |
CategoryTheory.MorphismProperty.IsStableUnderComonoid.rec | Mathlib.CategoryTheory.CopyDiscardCategory.Widesubcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{P : CategoryTheory.MorphismProperty C} →
{c : C} →
[inst_2 : CategoryTheory.ComonObj c] →
{motive : P.IsStableUnderComonoid c → Sort u} →
((counit_mem ... | null | false |
pow_div_pow_eventuallyEq_atTop | Mathlib.Analysis.Asymptotics.SpecificAsymptotics | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {p q : ℕ},
(fun x => x ^ p / x ^ q) =ᶠ[Filter.atTop] fun x => x ^ (↑p - ↑q) | null | true |
Std.HashMap.isEmpty_union | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
(m₁ ∪ m₂).isEmpty = (m₁.isEmpty && m₂.isEmpty) | null | true |
MeasureTheory.Measure.ae_ae_of_ae_comp | Mathlib.Probability.Kernel.Composition.MeasureComp | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{κ : ProbabilityTheory.Kernel α β} {p : β → Prop},
(∀ᵐ (ω : β) ∂μ.bind ⇑κ, p ω) → ∀ᵐ (ω' : α) ∂μ, ∀ᵐ (ω : β) ∂κ ω', p ω | null | true |
Ultrafilter._sizeOf_inst | Mathlib.Order.Filter.Ultrafilter.Defs | (α : Type u_2) → [SizeOf α] → SizeOf (Ultrafilter α) | null | false |
CategoryTheory.Functor.LaxMonoidal.comp._proof_6 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} 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_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
Lean.Elab.Term.expandShow | Lean.Elab.BuiltinNotation | Lean.Macro | null | true |
_private.Mathlib.NumberTheory.ModularForms.NormTrace.0.term𝒬 | Mathlib.NumberTheory.ModularForms.NormTrace | Lean.ParserDescr | null | true |
_private.Init.Data.List.Sublist.0.List.append_subset._simp_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, (l₁ ⊆ l₂) = ∀ {a : α}, a ∈ l₁ → a ∈ l₂ | null | false |
oneLePart_eq_self._simp_2 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : DivInvMonoid α] {a : α}, (a⁺ᵐ = a) = (1 ≤ a) | null | false |
IsFreeAddGroup.of.eq_1 | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : IsFreeAddGroup G],
IsFreeAddGroup.of = (IsFreeAddGroup.addEquiv G).toFun ∘ FreeAddGroup.of | null | true |
birkhoffAverage_one' | Mathlib.Dynamics.BirkhoffSum.Average | ∀ (R : Type u_1) {α : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (f : α → α) (g : α → M), birkhoffAverage R f g 1 = g | **Alias** of `birkhoffAverage_one`. | true |
Lean.Elab.Term.expandTermFor | Lean.Elab.Do.Switch | Lean.Macro | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.NegMulLog.0.Real.strictConvexOn_mul_log._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ∀ {α : Type u_1} [inst : Preorder α] {a : α} [NoMinOrder α], (Set.Iio a).Nonempty = True | null | false |
ProbabilityTheory.BrownianReal.integral_id_projectiveFamily' | Mathlib.Probability.BrownianMotion.GaussianProjectiveFamily | ∀ (I : Finset NNReal), ∫ (x : ↥I → ℝ), id x ∂ProbabilityTheory.BrownianReal.projectiveFamily I = 0 | null | true |
Std.Time.Awareness.only.inj | Std.Time.Format.Basic | ∀ {a a_1 : Std.Time.TimeZone}, Std.Time.Awareness.only a = Std.Time.Awareness.only a_1 → a = a_1 | null | true |
Std.DTreeMap.Internal.Impl.Const.size_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).size =
if k ∈ t ∧ (f (Std.DTreeMap.Internal.Impl.Const.get? t k)).isNone = true then t.size - 1
... | null | true |
Nat.one_lt_radical_iff | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ}, 1 < UniqueFactorizationMonoid.radical n ↔ 1 < n | null | true |
RingHom.comp | Mathlib.Algebra.Ring.Hom.Defs | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
{x : NonAssocSemiring α} →
{x_1 : NonAssocSemiring β} → {x_2 : NonAssocSemiring γ} → (β →+* γ) → (α →+* β) → α →+* γ | Composition of ring homomorphisms is a ring homomorphism. | true |
Sublattice.copy._proof_2 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (L : Sublattice α) (s : Set α), s = ↑L → InfClosed s | null | false |
CategoryTheory.StrongMono.iff_of_arrow_iso | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : B ⟶ A} {g : B' ⟶ A'}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g), CategoryTheory.StrongMono f ↔ CategoryTheory.StrongMono g | null | true |
LieModule.toEnd_pow_lie | Mathlib.Algebra.Lie.OfAssociative | ∀ (R : Type u) {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] (x y : L)
(z : M) (n : ℕ),
((LieModule.toEnd R L M) x ^ n) ⁅y, z⁆ =
∑ ij ∈ Finset.HasAntidiagonal.... | null | true |
_private.Lean.Meta.Match.MatcherApp.Basic.0.Lean.Meta.matchMatcherApp?.match_7 | Lean.Meta.Match.MatcherApp.Basic | (motive : Lean.ConstantInfo → Sort u_1) →
(__x : Lean.ConstantInfo) →
((info : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __x | null | false |
ArchimedeanClass.instLinearOrderFiniteElement._proof_6 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K]
(a b c : ArchimedeanClass.FiniteElement K), a ≤ b → b ≤ c → a ≤ c | null | false |
expNegInvGlue.zero_iff_nonpos._simp_1 | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, (expNegInvGlue x = 0) = (x ≤ 0) | null | false |
LinearMap.rank_le_range | Mathlib.LinearAlgebra.Dimension.LinearMap | ∀ {K : Type u} {V : Type v} {V' : Type v'} [inst : Semiring K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
[inst_3 : AddCommMonoid V'] [inst_4 : Module K V'] (f : V →ₗ[K] V'), f.rank ≤ Module.rank K V' | null | true |
TensorProduct.piRightInv | Mathlib.LinearAlgebra.TensorProduct.Pi | (R : Type u_1) →
[inst : CommSemiring R] →
(S : Type u_2) →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
(N : Type u_3) →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
[inst_5 : Module S N] →
[inst_6 : IsScalarTower... | (Implementation): Inverse for `TensorProduct.piRight`. | true |
List.Pairwise.below.rec | Init.Data.List.Basic | ∀ {α : Type u} {R : α → α → Prop} {motive : (a : List α) → List.Pairwise R a → Prop}
{motive_1 : {a : List α} → (t : List.Pairwise R a) → List.Pairwise.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ {a : α} {l : List α} (a_1 : ∀ a' ∈ l, R a a') (a_2 : List.Pairwise R l) (ih : List.Pairwise.below a_2)
(a_ih : motive... | null | false |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.dvd_gcd_iff.match_1_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (a b c : α) (motive : a ∣ b ∧ a ∣ c → Prop) (x : a ∣ b ∧ a ∣ c),
(∀ (hab : a ∣ b) (hac : a ∣ c), motive ⋯) → motive x | null | false |
CategoryTheory.hasLeftDualOfEquivalence | Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence | {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.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
[F.... | Pull back a left dual along an equivalence. | true |
CategoryTheory.AddMon.Hom.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} → (hom : M.X ⟶ N.X) → [isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] → M.Hom N | null | false |
Set.Sized.upShadow | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {r : ℕ},
Set.Sized r ↑𝒜 → Set.Sized (r + 1) ↑𝒜.upShadow | The upper shadow of a family of `r`-sets is a family of `r + 1`-sets. | true |
CategoryTheory.Limits.coneOpEquiv_functor_map_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {X Y : (CategoryTheory.Limits.Cone F)ᵒᵖ} (f : X ⟶ Y),
(CategoryTheory.Limits.coneOpEquiv.functor.map f).hom = f.unop.hom.op | null | true |
MeasurableSMul₂.measurable_smul | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} {inst : SMul M α} {inst_1 : MeasurableSpace M} {inst_2 : MeasurableSpace α}
[self : MeasurableSMul₂ M α], Measurable (Function.uncurry fun x1 x2 => x1 • x2) | null | true |
CategoryTheory.Core.functorToCore._proof_2 | Mathlib.CategoryTheory.Core | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : Type u_4} [inst_1 : CategoryTheory.Groupoid G]
(F : CategoryTheory.Functor G C) {X Y : G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.Groupoid.inv f)) =
CategoryTheory.CategoryStruct.id { of := F.obj X }.of | null | false |
_private.ImportGraph.Widget.Copy.0.ImportGraph.Widget.copyToClipboard.match_1 | ImportGraph.Widget.Copy | (motive : ImportGraph.Widget.CopyDisplay → Sort u_1) →
(display : ImportGraph.Widget.CopyDisplay) →
(Unit → motive ImportGraph.Widget.CopyDisplay.iconOnly) →
((hasIcon : Bool) → motive (ImportGraph.Widget.CopyDisplay.copiedText hasIcon)) →
((s : String) → (hasIcon : Bool) → motive (ImportGraph.Widge... | null | false |
LinearMap.instFunLike._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_2} {M₃ : Type u_1} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
(f g : M →ₛₗ[σ] M₃), (fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
CategoryTheory.Limits.punitCoconeIsColimit._proof_4 | Mathlib.CategoryTheory.Limits.Unit | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J]
{F : CategoryTheory.Functor J (CategoryTheory.Discrete PUnit.{u_2 + 1})} {c : CategoryTheory.Limits.Cocone F}
(s : CategoryTheory.Limits.Cocone F) (m : c.pt ⟶ s.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp (c.ι.app j) m = s.ι.app j) → m = Categ... | null | false |
CategoryTheory.Iso.inv_hom_id_app_map | Mathlib.CategoryTheory.NatIso | ∀ {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 ≅ G) (X : C) {D_1 : Type u_1}
[_instD : CategoryTheory.Category.{u_2, u_1} D_1] (F_1 : CategoryTheory.Functor D D_1),
CategoryTheory.CategoryStruct.comp... | null | true |
CategoryTheory.Limits.pullbackPullbackLeftIsPullback._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X₁ X₂ X₃ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₁)
(f₃ : X₂ ⟶ Y₂) (f₄ : X₃ ⟶ Y₂) [inst_1 : CategoryTheory.Limits.HasPullback f₁ f₂]
[inst_2 :
CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f... | null | false |
NonUnitalSubalgebra.map_toSubmodule | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : NonUnitalNonAssocSemiring B] [inst_3 : Module R A] [inst_4 : Module R B] {S : NonUnitalSubalgebra R A}
{f : A →ₙₐ[R] B}, (NonUnitalSubalgebra.map f S).toSubmodule = Submodule.map (↑f) S.toSubmodule | null | true |
RingCat.Hom.noConfusion | Mathlib.Algebra.Category.Ring.Basic | {P : Sort u_1} →
{R S : RingCat} →
{t : R.Hom S} → {R' S' : RingCat} → {t' : R'.Hom S'} → R = R' → S = S' → t ≍ t' → RingCat.Hom.noConfusionType P t t' | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.