name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_roc_add_add_eq_append._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n k : ℕ}, ¬m + n + 1 ≤ m + n + k + 1 → False | null | false |
LieAlgebra.Prod.instLieRing._proof_4 | Mathlib.Algebra.Lie.Prod | ∀ {L₁ : Type u_1} {L₂ : Type u_2} [inst : LieRing L₁] [inst_1 : LieRing L₂] (x y z : L₁ × L₂),
(⁅x.1, (⁅y.1, z.1⁆, ⁅y.2, z.2⁆).1⁆, ⁅x.2, (⁅y.1, z.1⁆, ⁅y.2, z.2⁆).2⁆) =
(⁅(⁅x.1, y.1⁆, ⁅x.2, y.2⁆).1, z.1⁆, ⁅(⁅x.1, y.1⁆, ⁅x.2, y.2⁆).2, z.2⁆) +
(⁅y.1, (⁅x.1, z.1⁆, ⁅x.2, z.2⁆).1⁆, ⁅y.2, (⁅x.1, z.1⁆, ⁅x.2, z.2⁆).... | null | false |
Path.Homotopy.transAssoc._proof_3 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Path.Homotopy.transAssocReparamAux 1 ∈ unitInterval | null | false |
FP.Float.isFinite | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float → Bool | null | true |
Std.Tactic.BVDecide.BVPred.instToString | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ToString Std.Tactic.BVDecide.BVPred | null | true |
Subtype.coe_mk | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} (a : α) (h : p a), ↑⟨a, h⟩ = a | null | true |
bernsteinPolynomial.variance | Mathlib.RingTheory.Polynomial.Bernstein | ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ),
∑ ν ∈ Finset.range (n + 1), (n • Polynomial.X - ↑ν) ^ 2 * bernsteinPolynomial R n ν =
n • Polynomial.X * (1 - Polynomial.X) | A certain linear combination of the previous three identities,
which we'll want later.
| true |
CategoryTheory.Comon.monoidal_tensorUnit_comon_counit | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.ComonObj.counit = CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.mem_insert._simp_1_2 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} [inst : Ord α] {x : α} {h : Batteries.BinaryHeap α}, (x ∈ h) = (x ∈ h.arr) | null | false |
_private.Mathlib.CategoryTheory.Bicategory.Coherence.0.CategoryTheory.FreeBicategory.inclusionPathAux.match_1.eq_1 | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ {B : Type u_2} [inst : Quiver B] {a : B} (motive : (x : B) → Quiver.Path a x → Sort u_3)
(h_1 : Unit → motive a Quiver.Path.nil) (h_2 : (x b : B) → (p : Quiver.Path a b) → (f : b ⟶ x) → motive x (p.cons f)),
(match a, Quiver.Path.nil with
| .(a), Quiver.Path.nil => h_1 ()
| x, p.cons f => h_2 x b p f) =
... | null | true |
List.Nodup.insert | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l : List α} {a : α} [inst : BEq α] [LawfulBEq α], l.Nodup → (List.insert a l).Nodup | null | true |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.getParamTypes._sparseCasesOn_1 | Lean.Compiler.LCNF.MonoTypes | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
FiniteAddGrp.instCategory._proof_8 | Mathlib.Algebra.Category.Grp.FiniteGrp | autoParam
(∀ {X Y : FiniteAddGrp.{u_1}} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
LinearMap.restrictScalars | Mathlib.Algebra.Module.LinearMap.Defs | (R : Type u_1) →
{S : Type u_5} →
{M : Type u_8} →
{M₂ : Type u_10} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R M₂] →
... | If `M` and `M₂` are both `R`-modules and `S`-modules and `R`-module structures
are defined by an action of `R` on `S` (formally, we have two scalar towers), then any `S`-linear
map from `M` to `M₂` is `R`-linear.
See also `LinearMap.map_smul_of_tower`. | true |
Equiv.sigmaSubtypeFiberEquiv | Mathlib.Logic.Equiv.Basic | {α : Type u_8} →
{β : Type u_9} → (f : α → β) → (p : β → Prop) → (∀ (x : α), p (f x)) → (y : Subtype p) × { x // f x = ↑y } ≃ α | If a predicate `p : β → Prop` is true on the range of a map `f : α → β`, then
`Σ y : {y // p y}, {x // f x = y}` is equivalent to `α`. | true |
BialgEquiv.ext | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
{e e' : A ≃ₐc[R] B}, (∀ (x : A), e x = e' x) → e = e' | null | true |
_private.Mathlib.RingTheory.PowerSeries.Evaluation.0.PowerSeries.HasEval.add._simp_1_1 | Mathlib.RingTheory.PowerSeries.Evaluation | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] {a : S},
PowerSeries.HasEval a = MvPowerSeries.HasEval fun x => a | null | false |
ModelWithCorners.MfldCat.Hom._mkInternal._flat_ctor | Mathlib.Geometry.Manifold.Category.MfldCat.OfModel | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{n : WithTop ℕ∞} → {M N : I.Mf... | null | false |
BoundedContinuousFunction.mkOfDiscrete | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
[DiscreteTopology α] →
(f : α → β) → (C : ℝ) → (∀ (x y : α), dist (f x) (f y) ≤ C) → BoundedContinuousFunction α β | If a function is bounded on a discrete space, it is automatically continuous,
and therefore gives rise to an element of the type of bounded continuous functions. | true |
CategoryTheory.Limits.coequalizerComparison._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_4} {X Y : C} [inst : CategoryTheory.Category.{u_3, u_4} C] (f g : Y ⟶ X) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D)
[inst_2 : CategoryTheory.Limits.HasCoequalizer f g],
CategoryTheory.CategoryStruct.comp (G.map f) (G.map (CategoryTheory.Limits.coe... | null | false |
DivisionSemiring.zpow_succ' | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_2} [self : DivisionSemiring K] (n : ℕ) (a : K), a ^ ↑n.succ = a ^ ↑n * a | `a ^ (n + 1) = a ^ n * a` | true |
_private.Init.Data.Dyadic.Round.0.Dyadic.roundDown_le.match_1_3 | Init.Data.Dyadic.Round | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (l : ℕ), x = Int.ofNat l → motive (Int.ofNat l)) →
(∀ (a : ℕ), x = Int.negSucc a → motive (Int.negSucc a)) → motive x | null | false |
Lean.Parser.«command__Builtin_simproc__[_]_(_):=_» | Init.Simproc | Lean.ParserDescr | A builtin simplification procedure.
| true |
egauge_smul_left | Mathlib.Analysis.Convex.EGauge | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] {c : 𝕜},
c ≠ 0 → ∀ (s : Set E) (x : E), egauge 𝕜 (c • s) x = egauge 𝕜 s x / ‖c‖ₑ | null | true |
StieltjesFunction.measure_Icc | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] (a b : R),
f.measure (Set.Icc a b) = ENNReal... | null | true |
MvPowerSeries.coeff_truncFinset_mul_truncFinset_eq_coeff_mul₂ | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s t : Finset (σ →₀ ℕ)},
IsLowerSet ↑s →
IsLowerSet ↑t →
∀ {x : σ →₀ ℕ} (f g : MvPowerSeries σ R),
x ∈ s →
x ∈ t →
((MvPowerSeries.truncFinset R s) f * (MvPowerSeries.truncFinset R t) g).coeff x =
(MvPowerSer... | A coefficient of a product of finset-truncated power series equals the coefficient of the
untruncated product, with the two truncation finsets `s` and `t` allowed to differ. | true |
Quaternion.normSq_intCast._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (z : ℤ), ↑z ^ 2 = Quaternion.normSq ↑z | null | false |
FreeAddGroup.Red.Step.not_rev._simp_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {x : α} {b : Bool},
FreeAddGroup.Red.Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂) = True | null | false |
CompHausLike.LocallyConstant.presheaf_ext | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{S : CompHausLike P} {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))}
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] (f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op ↧PUnit.{u + 1})))
... | To check equality of two elements of `X(S)`, it suffices to check equality after composing with
each `X(S) → X(Sᵢ)`.
| true |
LinearAlgebra.FreeProduct.lift_unique | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)] {B : Type w'} [inst_4 : Semiring B]
[inst_5 : Algebra R B] (maps : {i : I} → A i →ₐ[R] B) (f : LinearAlgebra.FreeProduct R A →ₐ[R] B),
(∀ (i : I), ... | null | true |
RingNormClass.casesOn | Mathlib.Algebra.Order.Hom.RingNorm | {F : Type u_4} →
{α : Type u_5} →
{β : Type u_6} →
[inst : NonUnitalNonAssocRing α] →
[inst_1 : Semiring β] →
[inst_2 : PartialOrder β] →
[inst_3 : FunLike F α β] →
{motive : RingNormClass F α β → Sort u} →
(t : RingNormClass F α β) →
... | null | false |
RootPairingCat.mk | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} →
[inst : CommRing R] →
(weight : Type v) →
[weightIsAddCommGroup : AddCommGroup weight] →
[weightIsModule : Module R weight] →
(coweight : Type v) →
[coweightIsAddCommGroup : AddCommGroup coweight] →
[coweightIsModule : Module R coweight] →
... | null | true |
LightProfinite.Extend.functor._proof_4 | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {F : CategoryTheory.Functor ℕᵒᵖ FintypeCat} (c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toLightProfinite))
{X Y Z : ℕᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.StructuredArrow.homMk (F.map (CategoryTheory.CategoryStruct.comp f g)) ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.... | null | false |
_private.Mathlib.FieldTheory.Galois.Basic.0.IsGalois.map_fixingSubgroup._simp_1_1 | Mathlib.FieldTheory.Galois.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
UInt64.instCommMonoid | Mathlib.Data.UInt | CommMonoid UInt64 | null | true |
Quaternion.re_im | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), a.im.re = 0 | null | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.Subsingleton.nodup._simp_1_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α}, (l.length = 0) = (l = []) | null | false |
Lean.Elab.Do.ForwardArg.mk.noConfusion | Lean.Elab.Do.ForwardSyntax | {P : Sort u} →
{binders : Array (Lean.TSyntax `Lean.Parser.Term.funBinder)} →
{body : Lean.DoSeq} →
{binders' : Array (Lean.TSyntax `Lean.Parser.Term.funBinder)} →
{body' : Lean.DoSeq} →
{ binders := binders, body := body } = { binders := binders', body := body' } →
(binders = ... | null | false |
CategoryTheory.GrothendieckTopology.instCompleteLattice._proof_5 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (a b c : CategoryTheory.GrothendieckTopology C),
a ≤ c →
b ≤ c →
{ sieves := sInf (CategoryTheory.GrothendieckTopology.sieves '' {x | a ≤ x ∧ b ≤ x}), top_mem' := ⋯,
pullback_stable' := ⋯, transitive' := ⋯ } ≤
c | null | false |
AddAction.IsPreprimitive.isCoatom_stabilizer_of_isPreprimitive | Mathlib.GroupTheory.GroupAction.Primitive | ∀ (G : Type u_3) [inst : AddGroup G] {X : Type u_4} [inst_1 : AddAction G X] [Nontrivial X]
[AddAction.IsPreprimitive G X] (a : X), IsCoatom (AddAction.stabilizer G a) | In a preprimitive action, stabilizers are maximal subgroups. | true |
CauSeq.lim_le | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : CauSeq.IsComplete α abs] {f : CauSeq α abs} {x : α}, f ≤ CauSeq.const abs x → f.lim ≤ x | null | true |
differentiable_star_iff._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] {E : Type u_2} [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : StarAddMonoid F]
[inst_6 : NormedSpace 𝕜 F] [StarModule 𝕜 F] [ContinuousStar F] {f : E → F} [TrivialStar ... | null | false |
Lean.Meta.Grind.AC.DiseqCnstrProof.ctorElimType | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u} → ℕ → Sort (max 1 u) | null | false |
Lean.Elab.PartialFixpoint.fixpointType._default | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType | null | false |
Submodule.mapHom._proof_2 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A] {A' : Type u_1}
[inst_3 : Semiring A'] [inst_4 : Algebra R A'] (f : A →ₐ[R] A'), Submodule.map f.toLinearMap ⊥ = ⊥ | null | false |
List.mapIdx_ne_nil_iff | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {l : List α}, List.mapIdx f l ≠ [] ↔ l ≠ [] | null | true |
ZMod.expand_card | Mathlib.FieldTheory.Finite.Basic | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : Polynomial (ZMod p)), (Polynomial.expand (ZMod p) p) f = f ^ p | null | true |
String.Slice.Pos.splits | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} (p : s.Pos), p.Splits (s.sliceTo p).copy (s.sliceFrom p).copy | null | true |
CategoryTheory.mop_rightUnitor | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).mop =
CategoryTheory.MonoidalCategoryStruct.leftUnitor { unmop := X } | null | true |
Representation.ind | Mathlib.RepresentationTheory.Induced | {k : Type u_1} →
{G : Type u_2} →
{H : Type u_3} →
[inst : CommRing k] →
[inst_1 : Group G] →
[inst_2 : Group H] →
(φ : G →* H) →
{A : Type u_4} →
[inst_3 : AddCommGroup A] →
[inst_4 : Module k A] → (ρ : Representation k G A) → Re... | Given a group homomorphism `φ : G →* H` and a `G`-representation `A`, this is
`(k[H] ⊗[k] A)_G` equipped with the `H`-representation defined by sending `h : H` and `⟦h₁ ⊗ₜ a⟧`
to `⟦h₁h⁻¹ ⊗ₜ a⟧`. | true |
_private.Mathlib.Order.Basic.0.Function.Injective.linearOrder._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), (a ≤ b ∨ b ≤ a) = True | null | false |
ULift.up.noConfusion | Init.Prelude | {α : Type s} → {P : Sort u} → {down down' : α} → { down := down } = { down := down' } → (down ≍ down' → P) → P | null | false |
ContinuousMap.compStarAlgHom._proof_5 | Mathlib.Topology.ContinuousMap.Star | ∀ (X : Type u_1) {𝕜 : Type u_4} {A : Type u_3} {B : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommSemiring 𝕜]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : IsTopologicalSemiring A] [inst_5 : Star A]
[inst_6 : Algebra 𝕜 A] [inst_7 : TopologicalSpace B] [inst_8 : Semiring B] [inst_9 : IsTopol... | null | false |
SheafOfModules.Submodule.instCompleteLattice._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Submodule | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} (s : Set M.Submodule),
sInf s ∈ lowerBounds s ∧ sInf s ∈ upperBounds (lowerBounds s) | null | false |
Lean.Lsp.RpcRef.mk.injEq | Lean.Server.Rpc.Basic | ∀ (p p_1 : USize), ({ p := p } = { p := p_1 }) = (p = p_1) | null | true |
GrpCat.SurjectiveOfEpiAuxs.τ_apply_infinity | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B),
(GrpCat.SurjectiveOfEpiAuxs.tau f) GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.infinity =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨↑(GrpCat.Hom.hom f).range, ⋯⟩ | null | true |
CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKanLift._proof_2 | Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {u : b ⟶ a}
(adj : CategoryTheory.Bicategory.Adjunction f u) {x : B} (h : x ⟶ a)
(s :
CategoryTheory.Bicategory.LeftLift u (CategoryTheory.CategoryStruct.comp h (CategoryTheory.CategoryStruct.id a))),
CategoryTheory.bicategoricalComp
... | null | false |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.processNullaryOrCat.match_1 | Lean.Elab.Syntax | (motive : Array Lean.Syntax → Sort u_1) →
(x : Array Lean.Syntax) → ((arg : Lean.Syntax) → motive #[arg]) → ((x : Array Lean.Syntax) → motive x) → motive x | null | false |
CategoryTheory.effectiveEpiStructOfRegularEpi._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B X : C} {f : X ⟶ B} (hf : CategoryTheory.RegularEpi f)
{W : C} (x : X ⟶ W),
(∀ {Z : C} (g₁ g₂ : Z ⟶ X),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ x = Categor... | null | false |
Std.HashMap.Equiv.of_toList_perm | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β},
m₁.toList.Perm m₂.toList → m₁.Equiv m₂ | null | true |
CommAlgCat.instConcreteCategoryAlgHomCarrier._proof_4 | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X Y Z : CommAlgCat R} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
exists_prop_of_true | Init.PropLemmas | ∀ {p : Prop} {q : p → Prop} (h : p), (∃ (h' : p), q h') ↔ q h | null | true |
MultipliableLocallyUniformlyOn.hasProdLocallyUniformlyOn | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
MultipliableLocallyUniformlyOn f s → HasProdLocallyUniformlyOn f (fun x => ∏' (i : ι), f i x) s | null | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_iff._simp_1_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p : α → Prop} {f : Filter α},
(∃ᶠ (x : α) in f, p x) = ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Truncated.0.SimplexCategory.Truncated.initial_inclusion._proof_2 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {n : ℕ} (Δ₁ : SimplexCategory) (hΔ₁ : Δ₁.len ≤ n),
NeZero (((CategoryTheory.ObjectProperty.ι fun a => a.len ≤ n).obj { obj := Δ₁, property := hΔ₁ }).len + 1) | null | false |
seminormFromBounded_of_mul_apply | Mathlib.Analysis.Normed.Unbundled.SeminormFromBounded | ∀ {R : Type u_1} [inst : CommRing R] {f : R → ℝ} {c : ℝ},
0 ≤ f →
(∀ (x y : R), f (x * y) ≤ c * f x * f y) →
∀ {x : R}, (∀ (y : R), f (x * y) = f x * f y) → seminormFromBounded' f x = f x | If `f : R → ℝ` is a nonnegative, multiplicatively bounded function and `x : R` is
multiplicative for `f`, then `seminormFromBounded' f x = f x`. | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.preprocess.normLevels._f | Lean.Meta.SynthInstance | Lean.Level →
Array ℕ → (us : List Lean.Level) → List.below (motive := fun us => ℕ → List Lean.Level) us → ℕ → List Lean.Level | null | false |
MonoidWithZeroHom.ValueGroup₀.restrict₀._proof_2 | Mathlib.Algebra.GroupWithZero.Range | ∀ {A : Type u_2} {B : Type u_1} [inst : MonoidWithZero A] [inst_1 : GroupWithZero B] (f : A →*₀ B) (a : A)
(h : ¬f a = 0), Units.mk0 (f a) h ∈ f.valueGroup | null | false |
SchwartzMap.smulLeftCLM_ofReal | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (𝕜' : Type u_10) [inst_4 : RCLike 𝕜'] [inst_5 : NormedSpace 𝕜' F] {g : E → ℝ},
Function.HasTemperateGrowth g →
∀ (f : SchwartzMap E F), (SchwartzMap.smulLeftCLM ... | null | true |
RBTree.RBNode.WF | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → (α → α → Ordering) → RBTree.RBNode α → Prop | The well-formedness invariant for a red-black tree. The first constructor is the real invariant,
and the others allow us to "cheat" in this file and define `insert` and `erase`,
which have more complex proofs that are delayed to `RBTree.Lemmas`.
| true |
ContinuousCohomology.zeroIso._proof_4 | Mathlib.RepresentationTheory.Homological.ContCohomology.LowDegree | ∀ {k : Type u_3} {G : Type u_1} [inst : Ring k] [inst_1 : Group G] [inst_2 : TopologicalSpace k]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (A : TopRep k G),
IsTopologicalAddGroup ↑(A.resolutionX 0) | null | false |
WittVector.inverseCoeff.match_1 | Mathlib.RingTheory.WittVector.DiscreteValuationRing | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
nhdsSet_interior | Mathlib.Topology.NhdsSet | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X}, nhdsSet (interior s) = Filter.principal (interior s) | null | true |
Std.TreeSet.Equiv.getLTD_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
t₁.Equiv t₂ → t₁.getLTD k fallback = t₂.getLTD k fallback | null | true |
HasCompactSupport.convolution_integrand_bound_right | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 ... | null | true |
Std.Http.URI.Path.normalize | Std.Http.Data.URI.Basic | Std.Http.URI.Path → Std.Http.URI.Path | Removes dot segments from the path according to RFC 3986 Section 5.2.4. This handles "."
(current directory) and ".." (parent directory) segments.
| true |
Lean.Elab.CompletionInfo.fieldId.injEq | Lean.Elab.InfoTree.Types | ∀ (stx : Lean.Syntax) (id : Option Lean.Name) (lctx : Lean.LocalContext) (structName : Lean.Name) (stx_1 : Lean.Syntax)
(id_1 : Option Lean.Name) (lctx_1 : Lean.LocalContext) (structName_1 : Lean.Name),
(Lean.Elab.CompletionInfo.fieldId stx id lctx structName =
Lean.Elab.CompletionInfo.fieldId stx_1 id_1 lctx... | null | true |
_private.Mathlib.Order.Cover.0.not_covBy_of_denselyOrdered.match_1_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LT α] {a b : α} (motive : (∃ a_1, a < a_1 ∧ a_1 < b) → Prop) (x : ∃ a_1, a < a_1 ∧ a_1 < b),
(∀ (w : α) (hc : a < w ∧ w < b), motive ⋯) → motive x | null | false |
Lean.PrettyPrinter.Delaborator.OmissionReason.string.sizeOf_spec | Lean.PrettyPrinter.Delaborator.Basic | ∀ (s : String), sizeOf (Lean.PrettyPrinter.Delaborator.OmissionReason.string s) = 1 + sizeOf s | null | true |
Lean.Meta.Sym.Context.config._default | Lean.Meta.Sym.SymM | Lean.Meta.Sym.Config | null | false |
_private.Mathlib.RingTheory.Ideal.Maximal.0.Ideal.exists_le_prime_disjoint.match_1_1 | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u_1} [inst : CommSemiring α] (I : Ideal α) (S : Submonoid α)
(motive : (∃ m, I ≤ m ∧ Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) m) → Prop)
(x : ∃ m, I ≤ m ∧ Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) m),
(∀ (p : Ideal α) (hIp : I ≤ p) (hp : Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) p), motive ⋯) →... | null | false |
MeasureTheory.ae_eq_trim_iff_of_aestronglyMeasurable | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] [TopologicalSpace.MetrizableSpace β]
{m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → β} (hm : m ≤ m0)
(hfm : MeasureTheory.AEStronglyMeasurable f μ) (hgm : MeasureTheory.AEStronglyMeasurable g μ),
MeasureTheory.AEStronglyMeasurable.mk... | null | true |
Lean.Meta.mkHEq | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Returns `a ≍ b`. | true |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.ExceptAt.eq_1 | Batteries.Data.BinaryHeap.WF | ∀ {α : Type u_1} {sz : ℕ} [inst : Ord α] (a : Vector α sz) (i : Fin sz),
Batteries.BinaryHeap.WF.ExceptAt✝ a i = ∀ (j : Fin sz), i ≠ j → Batteries.BinaryHeap.WF.Parent✝ a j | null | true |
String.Pos.instTransLe | Init.Data.String.OrderInstances | {s : String} → Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 | null | true |
Submodule.mulRightMap | Mathlib.LinearAlgebra.Finsupp.LSum | {R : Type u_1} →
[inst : Semiring R] →
{S : Type u_4} →
[inst_1 : Semiring S] →
[inst_2 : Module R S] →
[SMulCommClass R R S] →
[IsScalarTower R S S] →
(M : Submodule R S) → {N : Submodule R S} → {ι : Type u_5} → (ι → ↥N) → (ι →₀ ↥M) →ₗ[R] S | If `M` and `N` are submodules of an `R`-algebra `S`, `n : ι → N` is a family of elements, then
there is an `R`-linear map from `ι →₀ M` to `S` which maps `{ m_i }` to the sum of `m_i * n_i`.
This is used in the definition of linearly disjointness. | true |
CategoryTheory.MonoidalClosed.uncurry_ihomUncurry | Mathlib.CategoryTheory.Monoidal.Closed.InternalCurrying | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (x y z : C)
[inst_2 : CategoryTheory.Closed x] [inst_3 : CategoryTheory.Closed y]
[inst_4 : CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)],
CategoryTheory.MonoidalClosed.uncurry (Cat... | null | true |
CategoryTheory.LiftRightAdjoint.constructRightAdjoint | 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} →
... | Construct the right adjoint to `L`, with object map `constructRightAdjointObj`. | true |
ImportGraph.Lean.Import.Whitespace.ctorIdx | ImportGraph.Imports.Pretty | ImportGraph.Lean.Import.Whitespace → ℕ | null | false |
TopCat.pathEquiv._proof_4 | Mathlib.Topology.Homotopy.TopCat.Path | ContinuousMapClass (↑TopCat.I ≃ₜ ↑unitInterval) ↑TopCat.I ↑unitInterval | null | false |
AddCommMonoid.addTorsion.isAddTorsion | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : AddCommMonoid G], IsAddTorsion ↥(AddCommMonoid.addTorsion G) | Torsion additive submonoids are torsion. | true |
Bimod.AssociatorBimod.hom_inv_id | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
[i... | null | true |
Ideal.snd_comp_quotientInfEquivQuotientProd | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_2} [inst : CommRing R] (I J : Ideal R) (coprime : IsCoprime I J),
(RingHom.snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientInfEquivQuotientProd J coprime) = Ideal.Quotient.factor ⋯ | null | true |
CategoryTheory.Profunctor.ofHom._proof_4 | Mathlib.CategoryTheory.Profunctor.Basic | ∀ {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_5, u_3} D] {P Q : CategoryTheory.ProfunctorCore.{u_4, u_1, u_5, u_2, u_3} C D}
(f : P.Hom Q) ⦃X Y : C⦄ (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Profunctor.ofCore P).map f_1)... | null | false |
Subsemiring.mem_centralizer_iff | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] {s : Set R} {z : R}, z ∈ Subsemiring.centralizer s ↔ ∀ g ∈ s, g * z = z * g | null | true |
BitVec.extractLsb'_append_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {w len : ℕ} {x : BitVec (w + len)}, BitVec.extractLsb' len w x ++ BitVec.extractLsb' 0 len x = x | null | true |
Std.Internal.List.getValue?_insertEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((_ : α) × β)} {k a : α} {v : β},
Std.Internal.List.getValue? a (Std.Internal.List.insertEntry k v l) =
if (k == a) = true then some v else Std.Internal.List.getValue? a l | null | true |
sSupHom.instSSupHomClass | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : SupSet α] [inst_1 : SupSet β], sSupHomClass (sSupHom α β) α β | null | true |
DFinsupp.Colex.decidableLE | Mathlib.Data.DFinsupp.Lex | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : (i : ι) → Zero (α i)] →
[inst_1 : LinearOrder ι] → [inst_2 : (i : ι) → LinearOrder (α i)] → DecidableLE (Colex (Π₀ (i : ι), α i)) | The less-or-equal relation for the colexicographic ordering is decidable. | true |
VectorFourier.norm_fourierIntegral_le_integral_norm | Mathlib.Analysis.Fourier.FourierTransform | ∀ {𝕜 : Type u_1} [inst : CommRing 𝕜] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : MeasurableSpace V] {W : Type u_3} [inst_4 : AddCommGroup W] [inst_5 : Module 𝕜 W] {E : Type u_4}
[inst_6 : NormedAddCommGroup E] [inst_7 : NormedSpace ℂ E] (e : AddChar 𝕜 Circle) (μ : MeasureTheory.Mea... | The uniform norm of the Fourier integral of `f` is bounded by the `L¹` norm of `f`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.