name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Batteries.Data.List.Lemmas.0.List.isSome_isPrefixOf?_eq_isPrefixOf.match_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Prop) (xs ys : List α),
(∀ (x : List α), motive [] x) →
(∀ (head : α) (tail : List α), motive (head :: tail) []) →
(∀ (head : α) (tail : List α) (head_1 : α) (tail_1 : List α), motive (head :: tail) (head_1 :: tail_1)) →
motive xs ys | null | false |
Aesop.PhaseSpec.phase | Aesop.Builder.Basic | Aesop.PhaseSpec → Aesop.PhaseName | null | true |
_private.Mathlib.Algebra.Group.Pointwise.Finset.Basic.0.Finset.isUnit_coe._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} {s : Finset α} {a : α}, (↑s = {a}) = (s = {a}) | null | false |
Orientation.norm_div_cos_oangle_add_right_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, o.oangle x y = ↑(Real.pi / 2) → ‖x‖ / (o.oangle x (x + y)).cos = ‖x + y‖ | A side of a right-angled triangle divided by the cosine of the adjacent angle equals the
hypotenuse. | true |
TemperedDistribution.delta_apply | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x : E) (f : SchwartzMap E ℂ),
(TemperedDistribution.delta x) f = f x | null | true |
Lean.CasesAltInfo.ctor.inj | Lean.Meta.CasesInfo | ∀ {ctorName : Lean.Name} {numFields : ℕ} {ctorName_1 : Lean.Name} {numFields_1 : ℕ},
Lean.CasesAltInfo.ctor ctorName numFields = Lean.CasesAltInfo.ctor ctorName_1 numFields_1 →
ctorName = ctorName_1 ∧ numFields = numFields_1 | null | true |
_private.Mathlib.Analysis.Normed.Group.Pointwise.0.IsCompact.mul_closedBall_one._simp_1_1 | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a : α}, (a ∈ s * t) = ∃ x ∈ s, ∃ y ∈ t, x * y = a | null | false |
EquivLike.mk | Mathlib.Basic.FunLike.Equiv | {E : Sort u_1} →
{α : outParam (Sort u_2)} →
{β : outParam (Sort u_3)} →
(coe : E → α → β) →
(inv : E → β → α) →
(∀ (e : E), Function.LeftInverse (inv e) (coe e)) →
(∀ (e : E), Function.RightInverse (inv e) (coe e)) →
(∀ (e g : E), coe e = coe g → inv e = inv g → ... | null | true |
List.offDiag_singleton | Mathlib.Data.List.OffDiag | ∀ {α : Type u_1} (a : α), [a].offDiag = [] | null | true |
Std.DTreeMap.Internal.Impl.entryAtIdx?._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Impl α β → ℕ → Option ((a : α) × β a) | null | false |
UpperSet.sdiff_singleton | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s : UpperSet α) (a : α), s.sdiff {a} = s.erase a | null | true |
instStarMulWithConvMatrix | Mathlib.LinearAlgebra.Matrix.WithConv | {m : Type u_1} → {n : Type u_2} → {α : Type u_3} → [inst : Mul α] → [StarMul α] → StarMul (WithConv (Matrix m n α)) | null | true |
Nat.coprime_ordCompl | Mathlib.Data.Nat.Factorization.Basic | ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → p.Coprime (n / p ^ n.factorization p) | null | true |
CategoryTheory.Localization.instCategoryLocalizedMonoidal._aux_5 | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {C : Type u_4} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{u_3, u_4} C] →
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 ... | null | false |
UniformSpace.Completion.instNormedFieldOfCompletableTopField._proof_2 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : NormedField A], Continuous fun x => ‖x.1‖ * ‖x.2‖ | null | false |
Pi.vaddCommClass' | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} {β : ι → Type u_5} [inst : (i : ι) → VAdd M (β i)]
[inst_1 : (i : ι) → VAdd (α i) (β i)] [∀ (i : ι), VAddCommClass M (α i) (β i)],
VAddCommClass M ((i : ι) → α i) ((i : ι) → β i) | null | true |
Set.image2_iUnion₂_right | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_5} {κ : ι → Sort u_8} (f : α → β → γ) (s : Set α)
(t : (i : ι) → κ i → Set β), Set.image2 f s (⋃ i, ⋃ j, t i j) = ⋃ i, ⋃ j, Set.image2 f s (t i j) | null | true |
Dynamic.mk | Init.Dynamic | {α : Type u_1} → [TypeName α] → α → Dynamic | Stores the provided value in a `Dynamic`.
Use `Dynamic.get? α` to retrieve it.
| true |
CategoryTheory.InjectiveResolution.Hom.noConfusionType | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} →
{I : CategoryTheory.InjectiveResolution Z} →
{Z' : C} →
{I' : C... | null | false |
BitVec.fill_true | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, BitVec.fill w true = BitVec.allOnes w | null | true |
Std.Internal.List.keys_nil | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v}, Std.Internal.List.keys [] = [] | null | true |
USize.zero_and | Init.Data.UInt.Bitwise | ∀ {a : USize}, 0 &&& a = 0 | null | true |
DoubleCentralizer.instCoeTC | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u_1} →
{A : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] →
[inst_2 : NormedSpace 𝕜 A] →
[inst_3 : SMulCommClass 𝕜 A A] → [inst_4 : IsScalarTower 𝕜 A A] → CoeTC A (DoubleCentralizer 𝕜 A) | The natural coercion of `A` into `𝓜(𝕜, A)` given by sending `a : A` to the pair of linear
maps `Lₐ Rₐ : A →L[𝕜] A` given by left- and right-multiplication by `a`, respectively.
Warning: if `A = 𝕜`, then this is a coercion which is not definitionally equal to the
`algebraMap 𝕜 𝓜(𝕜, 𝕜)` coercion, but these are p... | true |
CategoryTheory.Limits.Fork.isLimitForkPushoutEquivIsColimitForkOpPullback._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasPushout f f],
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.pushoutIsoUnopPullback f f).op.symm ≪≫ CategoryTheory.eqToIso ⋯).hom
(CategoryTheory.Limits.pullback.snd f.op f... | null | false |
Finset.sum_set_coe | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] {f : ι → M} (s : Set ι) [inst_1 : Fintype ↑s],
∑ i, f ↑i = ∑ i ∈ s.toFinset, f i | null | true |
Lean.Grind.CommRing.Poly.mulConstC.go._unsafe_rec | Init.Grind.Ring.CommSolver | ℤ → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | false |
MeasureTheory.Filtration.HasLimitProcess.ae_tendsto_limitProcess | Mathlib.Probability.Process.LimitProcess | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} [inst : Preorder ι] {mΩ : MeasurableSpace Ω}
[inst_1 : TopologicalSpace E] {P : MeasureTheory.Measure Ω} {𝓕 : MeasureTheory.Filtration ι mΩ} {X : ι → Ω → E}
[inst_2 : Zero E],
MeasureTheory.Filtration.HasLimitProcess X 𝓕 P →
∀ᵐ (ω : Ω) ∂P, Filter.Tendsto (fun x... | null | true |
NumberField.instCommRingRingOfIntegers._aux_1 | Mathlib.NumberTheory.NumberField.Basic | (K : Type u_1) → [inst : Field K] → NumberField.RingOfIntegers K | null | false |
Sublattice.instLatticeCoe._proof_4 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (L : Sublattice α) (x x_1 : ↥L), ↑(x ⊔ x_1) = ↑(x ⊔ x_1) | null | false |
Lean.Meta.CaseArraySizesSubgoal.ctorIdx | Lean.Meta.Match.CaseArraySizes | Lean.Meta.CaseArraySizesSubgoal → ℕ | null | false |
continuous_sInf_dom₂ | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_5} {Y : Type u_6} {Z : Type u_7} {f : X → Y → Z} {tas : Set (TopologicalSpace X)}
{tbs : Set (TopologicalSpace Y)} {tX : TopologicalSpace X} {tY : TopologicalSpace Y} {tc : TopologicalSpace Z},
tX ∈ tas → tY ∈ tbs → (Continuous fun p => f p.1 p.2) → Continuous fun p => f p.1 p.2 | A version of `continuous_sInf_dom` for binary functions | true |
Aesop.Goal.safeRapps | Aesop.Tree.Data | Aesop.Goal → BaseIO (Array Aesop.RappRef) | null | true |
Option.or_of_isNone | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o o' : Option α}, o.isNone = true → o.or o' = o' | null | true |
Inclusion.Interval.ctorIdx | Mathlib.Tactic.Inclusion.Extension.Interval | {α : Type u_3} → Inclusion.Interval α → ℕ | null | false |
CategoryTheory.CommGrpObj.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{X : C} →
(one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
(mul : CategoryTheory.MonoidalCategoryStru... | null | false |
MeromorphicAt.meromorphicTrailingCoeffAt_comp | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜} {g : 𝕜 → 𝕜},
MeromorphicAt f (g x) →
AnalyticAt 𝕜 g x →
¬Filter.EventuallyConst g (nhds x) →
meromorphicTrailingCoeffAt (f ∘ g) x =
me... | If `g` is analytic at `x` and not locally constant, and `f` is meromorphic at `g x`, express the
trailing coefficient of `f ∘ g` at `x` in terms of `g` and `f`.
| true |
Lean.Meta.Simp.UsedSimps._sizeOf_inst | Lean.Meta.Tactic.Simp.Types | SizeOf Lean.Meta.Simp.UsedSimps | null | false |
Real.sin_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ (x : ℝ), Real.sin (Real.arccos x) = √(1 - x ^ 2) | null | true |
CategoryTheory.Discrete.equivOfEquivalence._proof_1 | Mathlib.CategoryTheory.Discrete.Basic | ∀ {α : Type u_1} {β : Type u_2} (h : CategoryTheory.Discrete α ≌ CategoryTheory.Discrete β) (a : α),
(CategoryTheory.Discrete.as ∘ h.inverse.obj ∘ CategoryTheory.Discrete.mk)
((CategoryTheory.Discrete.as ∘ h.functor.obj ∘ CategoryTheory.Discrete.mk) a) =
a | null | false |
ProbabilityTheory.«term_⊗ₖ_» | Mathlib.Probability.Kernel.Composition.CompProd | Lean.TrailingParserDescr | Composition-Product of kernels. For s-finite kernels, it satisfies
`∫⁻ bc, f bc ∂(compProd κ η a) = ∫⁻ b, ∫⁻ c, f (b, c) ∂(η (a, b)) ∂(κ a)`
(see `ProbabilityTheory.Kernel.lintegral_compProd`).
If either of the kernels is not s-finite, `compProd` is given the junk value 0. | true |
NumberField.IsCMField.complexConj._proof_1 | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [Algebra.IsIntegral ℚ K], Nonempty (K →+* ℂ) | null | false |
AddSubgroup.pi_mem_of_single_mem | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_2} {f : η → Type u_3} [inst : (i : η) → AddGroup (f i)] [Finite η] [inst_2 : DecidableEq η]
{H : AddSubgroup ((i : η) → f i)} (x : (i : η) → f i), (∀ (i : η), Pi.single i (x i) ∈ H) → x ∈ H | null | true |
AbsoluteValue.uniformSpace._proof_1 | Mathlib.Topology.UniformSpace.AbsoluteValue | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] {R : Type u_2} [inst_2 : CommRing R]
(abv : AbsoluteValue R 𝕜) (x : R), abv (x - x) = 0 | null | false |
Cardinal.toENat_eq_zero | Mathlib.SetTheory.Cardinal.ENat | ∀ {c : Cardinal.{u}}, Cardinal.toENat c = 0 ↔ c = 0 | null | true |
NonemptyInterval.instNSMul.eq_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddMonoid α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] [inst_3 : AddRightMono α],
NonemptyInterval.instNSMul = { smul := fun n s => { toProd := n • s.toProd, fst_le_snd := ⋯ } } | null | true |
CategoryTheory.Functor.mapSkeleton_injective | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.Full] [F.Faithful], Function.Injective F.mapSkeleton.obj | null | true |
AlgebraicTopology.DoldKan.degeneraciesVanish_zero_iff_true._simp_1 | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {T : C} (f : X.obj (Opposite.op { len := 0 }) ⟶ T),
AlgebraicTopology.DoldKan.DegeneraciesVanish f = True | null | false |
Lean.Lsp.SymbolTag | Lean.Data.Lsp.LanguageFeatures | Type | null | true |
Prod.instSemilatticeInf | Mathlib.Order.Lattice | (α : Type u) → (β : Type v) → [SemilatticeInf α] → [SemilatticeInf β] → SemilatticeInf (α × β) | null | true |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.exists_open_approx._simp_1_1 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α] {μ : F}
{s t : Set α}, s ⊆ t → (μ s ≤ μ t) = True | null | false |
CategoryTheory.JointlyReflectIsomorphisms.mk | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
(∀ {X Y : C} (f : X ⟶ Y) [∀ (i : I), CategoryTheory.IsIso ((F i).map f)], CategoryTheory.IsIso f) →
Categ... | null | true |
Lean.Lsp.RpcOptions.mk._flat_ctor | Lean.Data.Lsp.Extra | Option Lean.Lsp.HighlightMatchesOptions → Option Lean.Lsp.RpcWireFormat → Lean.Lsp.RpcOptions | null | false |
CategoryTheory.sheafOver_obj | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{J : CategoryTheory.GrothendieckTopology C} (ℱ : CategoryTheory.Sheaf J A) (E : A),
(CategoryTheory.sheafOver ℱ E).obj = ℱ.obj.comp (CategoryTheory.coyoneda.obj (Opposite.op E)) | null | true |
CategoryTheory.Bimon.instBimonObjXXMon._proof_12 | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Bimon C),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one CategoryTheory.ComonObj.counit.hom =
CategoryTheory.CategoryStruct.id... | null | false |
LinearPMap.IsClosable.existsUnique | Mathlib.Topology.Algebra.Module.LinearPMap | ∀ {R : Type u_1} {E : Type u_2} {F : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module R E] [inst_4 : Module R F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F]
[inst_7 : ContinuousAdd E] [inst_8 : ContinuousAdd F] [inst_9 : TopologicalSpace R] [inst_10 ... | The closure is unique. | true |
MvPowerSeries.instAddGroup._proof_7 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : AddGroup R],
autoParam (∀ (a b : MvPowerSeries σ R), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
_private.Mathlib.Logic.Embedding.Set.0.subtypeOrEquiv._proof_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} (p q : α → Prop) (x : α), p x → p x ∨ q x | null | false |
Std.Sat.AIG.mkGate_decl_eq._proof_2 | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (idx : ℕ) (aig : Std.Sat.AIG α) (input : aig.BinaryInput)
{h : idx < aig.decls.size},
aig.decls.size ≤ (aig.mkGate input).aig.decls.size → idx < (aig.mkGate input).aig.decls.size | null | false |
Polynomial.IsEisensteinAt.mem | Mathlib.RingTheory.Polynomial.Eisenstein.Basic | ∀ {R : Type u} [inst : CommSemiring R] {f : Polynomial R} {𝓟 : Ideal R},
f.IsEisensteinAt 𝓟 → ∀ {n : ℕ}, n < f.natDegree → f.coeff n ∈ 𝓟 | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.any_iff_exists._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α} {start stop : ℕ},
(as.any p start stop = true) = ∃ i, ∃ (x : i < as.size), start ≤ i ∧ i < stop ∧ p as[i] = true | null | false |
_private.Mathlib.Probability.Kernel.Proper.0.ProbabilityTheory.Kernel.IsProper.lintegral_indicator_mul_indicator._simp_1_2 | Mathlib.Probability.Kernel.Proper | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
CategoryTheory.LiftRightAdjoint.otherMap | Mathlib.CategoryTheory.Adjunction.Lifting.Right | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{U : CategoryTheory.Functor A B} →
{F : CategoryTheory.Functor B A} →
... | (Implementation)
To construct the right adjoint, we use the equalizer of `U' F η_X` with the composite
`U' F X ⟶ U' F L U' F X ⟶ U' F U F L U' F X ⟶ U' F U F X`
where the first morphism is `ι_U'FX`, the second is `U' F η_LU'FX` and the third is `U' F U δ_FX`.
We will show that this equalizer exists and that it forms ... | true |
Std.DTreeMap.Internal.Impl.getKey?_union! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁.union! m₂).getKey? k = (m₂.getKey? k).or (m₁.getKey? k) | null | true |
Lean.SimplePersistentEnvExtensionDescr.noConfusionType | Lean.EnvExtension | Sort u →
{α σ : Type} →
Lean.SimplePersistentEnvExtensionDescr α σ → {α' σ' : Type} → Lean.SimplePersistentEnvExtensionDescr α' σ' → Sort u | null | false |
ContinuousLinearEquiv.automorphismGroup._proof_10 | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] (M₁ : Type u_2) [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (f : M₁ ≃L[R₁] M₁), f * 1 = f * 1 | null | false |
RingNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | (R : Type u_2) → [NonUnitalNonAssocRing R] → Type u_2 | A function `f : R → ℝ` is a norm on a (nonunital) ring if it is a seminorm and `f x = 0`
implies `x = 0`. | true |
_private.Mathlib.SetTheory.Cardinal.Regular.0.Cardinal.isSingular_aleph_omega0._simp_1_1 | Mathlib.SetTheory.Cardinal.Regular | ∀ {o : Ordinal.{u_1}}, (Cardinal.aleph o).IsSingular = (Order.IsSuccLimit o ∧ o.cof < Cardinal.aleph o) | null | false |
TwoSidedIdeal.coeAddMonoidHom._proof_2 | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R), ↑0 = ↑0 | null | false |
ContextFreeGrammar.Derives | Mathlib.Computability.ContextFreeGrammar | {T : Type u_1} → (g : ContextFreeGrammar T) → List (Symbol T g.NT) → List (Symbol T g.NT) → Prop | Given a context-free grammar `g` and strings `u` and `v`
`g.Derives u v` means that `g` can transform `u` to `v` in some number of rewriting steps. | true |
mkFactorOrderIsoOfFactorDvdEquiv_apply_coe | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {N : Type u_2} [inst_1 : CommMonoidWithZero N] [inst_2 : Subsingleton Mˣ]
[inst_3 : Subsingleton Nˣ] {m : M} {n : N} {d : { l // l ∣ m } ≃ { l // l ∣ n }}
(hd : ∀ (l l' : { l // l ∣ m }), ↑(d l) ∣ ↑(d l') ↔ ↑l ∣ ↑l') (l : ↑(Set.Iic (Associates.mk m))),
↑((mkFactorOrd... | null | true |
Nat.sub_add_cancel | Init.Data.Nat.Basic | ∀ {n m : ℕ}, m ≤ n → n - m + m = n | null | true |
UInt64.toUSize_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ},
UInt64.size ≤ n →
(UInt64.ofNatClamp n).toUSize = USize.ofNatLT (USize.size - 1) UInt64.toUSize_ofNatClamp_of_le._proof_1 | null | true |
SeminormedAddGroup.noConfusionType | Mathlib.Analysis.Normed.Group.Defs | Sort u → {E : Type u_4} → SeminormedAddGroup E → {E' : Type u_4} → SeminormedAddGroup E' → Sort u | null | false |
Meromorphic.meromorphic_comp_sub_const_iff_meromorphic | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {c : 𝕜}, Meromorphic (f ∘ fun x => x - c) ↔ Meromorphic f | `Meromorphic` is invariant under translation. | true |
KaehlerDifferential.D._proof_3 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S], SMulCommClass R S S | null | false |
_private.Init.Data.Array.Lemmas.0.Array.back_append._simp_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, (xs = #[]) = (xs.size = 0) | null | false |
Lean.Widget.WidgetSource.noConfusionType | Lean.Widget.UserWidget | Sort u → Lean.Widget.WidgetSource → Lean.Widget.WidgetSource → Sort u | null | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.Internal.List.interSmallerFn.match_1.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_2} {β : α → Type u_1} (motive : Option ((a : α) × β a) → Sort u_3) (kv' : (a : α) × β a)
(h_1 : (kv' : (a : α) × β a) → motive (some kv')) (h_2 : Unit → motive none),
(match some kv' with
| some kv' => h_1 kv'
| none => h_2 ()) =
h_1 kv' | null | true |
IsScalarTower.contMDiffSMul | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {H' : Type u_4}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | If `G` acts continuously differentiably on `G'` and `G'` acts continuously differentiably on
`M`, then `G` acts continuously differentiably on `M`. | true |
Lean.Meta.NativeEqTrueResult.casesOn | Lean.Meta.Native | {motive : Lean.Meta.NativeEqTrueResult → Sort u} →
(t : Lean.Meta.NativeEqTrueResult) →
((prf : Lean.Expr) → motive (Lean.Meta.NativeEqTrueResult.success prf)) →
motive Lean.Meta.NativeEqTrueResult.notTrue → motive t | null | false |
ProfiniteAddGrp.instHasForget₂FiniteAddGrpAddMonoidHomCarrierToAddGrpContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfinite._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (X : FiniteAddGrp.{u_1}),
ProfiniteAddGrp.ofFiniteAddGrpHom (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (ProfiniteAddGrp.ofFiniteAddGrp X) | null | false |
_private.Mathlib.Tactic.CongrExclamation.0.Lean.MVarId.congrImplies?'._sparseCasesOn_1 | Mathlib.Tactic.CongrExclamation | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
MeasureTheory.StronglyMeasurable.stronglyMeasurable_in_set | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Zero β] {s : Set α}
{f : α → β},
MeasurableSet s →
MeasureTheory.StronglyMeasurable f →
(∀ x ∉ s, f x = 0) →
∃ fs,
(∀ (x : α), Filter.Tendsto (fun n => (fs n) x) Filter.atTop (nhds (f x))) ∧ ∀ x... | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.cnfSatAssignment.eq_1 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (assign1 : ℕ → Bool),
Std.Sat.AIG.toCNF.cnfSatAssignment✝ aig assign1 =
Std.Sat.AIG.toCNF.mixAssigns✝ assign1 fun idx =>
⟦assign1, { aig := aig, ref := { gate := ↑idx, invert := false, hgate := ⋯ } }⟧ | null | true |
Valuation.exists_coe_mem_extension_eq | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {K : Type u_2} {Γ₀ : Type u_3} [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K]
[inst_3 : IsValuativeTopology K] [inst_4 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation K Γ₀)
[inst_5 : v.Compatible] [inst_6 : IsUniformAddGroup K] {x : UniformSpace.Completion K}
{U : Set (UniformSpace.Com... | Every neighbourhood of `x` in the completion of `K` contains an element `r` of `K` with
`v r = v.extension x`. | true |
CategoryTheory.HasSplitCoequalizer.rec | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.HasSplitCoequalizer f g → Sort u_1} →
((splittable : ∃ Z h, Nonempty (CategoryTheory.IsSplitCoequalizer f g h)) → motive ⋯) →
(t : CategoryTheory.HasSplitCoequalizer ... | null | false |
Lean.Elab.Command.StatefulLinterEntry.ctorIdx | Lean.Elab.Command | Lean.Elab.Command.StatefulLinterEntry → ℕ | null | false |
SemiNormedGrp.instConcreteCategoryNormedAddGroupHomCarrier._proof_3 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {X : SemiNormedGrp} (x : X.carrier), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
_private.Mathlib.Data.Finsupp.Single.0.Finsupp.erase_single_ne._proof_1_1 | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] {a a' : α} {b : M},
a ≠ a' → (Finsupp.erase a fun₀ | a' => b) = fun₀ | a' => b | null | false |
LinearMap.BilinForm.isNonneg_def | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : LE R]
{B : LinearMap.BilinForm R M}, B.IsNonneg ↔ ∀ (x : M), 0 ≤ (B x) x | null | true |
MeasureTheory.ProbabilityMeasure.toWeakDualBCNN | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | {Ω : Type u_1} →
[inst : MeasurableSpace Ω] →
[inst_1 : TopologicalSpace Ω] →
[OpensMeasurableSpace Ω] →
MeasureTheory.ProbabilityMeasure Ω → WeakDual NNReal (BoundedContinuousFunction Ω NNReal) | Probability measures yield elements of the `WeakDual` of bounded continuous nonnegative
functions via `MeasureTheory.FiniteMeasure.testAgainstNN`, i.e., integration. | true |
instLinearOrderNNRat._proof_8 | Mathlib.Data.NNRat.Defs | ∀ (a b : ℚ≥0), a ≤ b → b ≤ a → a = b | null | false |
Set.notMem_sdiff_of_mem | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α} {x : α}, x ∈ t → x ∉ s \ t | null | true |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandDeclNamespace?._sparseCasesOn_5 | Lean.Elab.Declaration | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Submodule.quotientRel | Mathlib.LinearAlgebra.Quotient.Defs | {R : Type u_1} →
{M : Type u_2} → [inst : Ring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Submodule R M → Setoid M | The equivalence relation associated to a submodule `p`, defined by `x ≈ y` iff `-x + y ∈ p`.
Note this is equivalent to `y - x ∈ p`, but defined this way to be defeq to the `AddSubgroup`
version, where commutativity can't be assumed. | true |
CategoryTheory.GrothendieckTopology.sheafifyCompIso.congr_simp | Mathlib.CategoryTheory.Sites.CompatibleSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
(F : CategoryTheory.Functor D E)
[inst_3 :
∀ (J : CategoryTheory.Limits.Multicospan... | null | true |
ZeroHom.smul_apply | Mathlib.Algebra.GroupWithZero.Action.Hom | ∀ {M : Type u_1} {A : Type u_3} {B : Type u_4} [inst : Zero A] [inst_1 : Zero B] [inst_2 : SMulZeroClass M B] (m : M)
(f : ZeroHom A B) (a : A), (m • f) a = m • f a | null | true |
_private.Mathlib.Algebra.Group.Submonoid.Support.0.Subgroup.gciToSubmonoidMulSupport._simp_1 | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_1} [inst : Group G] {p q : Subgroup G}, (p ≤ q) = (p.toSubmonoid ≤ q.toSubmonoid) | null | false |
DirectLimit.map._proof_1 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_3} [inst : Preorder ι] {F₁ : ι → Type u_5} {F₂ : ι → Type u_1} {T₁ : ⦃i j : ι⦄ → i ≤ j → Sort u_4}
(f₁ : (i j : ι) → (h : i ≤ j) → T₁ h) [inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₁ h) (F₁ i) (F₁ j)]
[DirectedSystem F₁ fun x1 x2 x3 => ⇑(f₁ x1 x2 x3)] {T₂ : ⦃i j : ι⦄ → i ≤ j → Sort u_2}
(f₂ : (i j... | null | false |
CategoryTheory.IsIso.comp_inv_eq._simp_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) = (f = CategoryTheory.CategoryStruct.comp g α) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.