name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
norm_pow | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] [NormOneClass α] [NormMulClass α] (a : α) (n : ℕ), ‖a ^ n‖ = ‖a‖ ^ n | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minKey?_eq_some_iff_getKey?_eq_self_and_forall._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | null | false |
Lean.instHashableLevelMVarId.hash | Lean.Level | Lean.LevelMVarId → UInt64 | null | true |
AlgHomClass.toRingHomClass | Mathlib.Algebra.Algebra.Hom | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} {inst : CommSemiring R}
{inst_1 : Semiring A} {inst_2 : Semiring B} {inst_3 : Algebra R A} {inst_4 : Algebra R B} {inst_5 : FunLike F A B}
[self : AlgHomClass F R A B], RingHomClass F A B | null | true |
Std.Time.DateTime.fromDateTimeWithZoneString | Std.Time.Format | String → Except String Std.Time.DateTime | Parses a `String` in the dateTimeWithZone format and returns a `DateTime` object in the GMT time zone.
| true |
suggestSteps | Mathlib.Tactic.Widget.Calc | Array Lean.SubExpr.GoalsLocation →
Lean.Expr → CalcParams → Lean.MetaM (String × String × Option (String.Pos.Raw × String.Pos.Raw)) | Return the link text and inserted text above and below of the calc widget. | true |
AffineSubspace.direction_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], ⊥.direction = ⊥ | The direction of `⊥` is the submodule `⊥`. | true |
DerivedCategory.instPretriangulated._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopyCategory.subcategoryAcyclic C).trW.IsCompatibleWithTriangulation | null | false |
connectedComponentIn_mem_nhds | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {F : Set α} {x : α},
F ∈ nhds x → connectedComponentIn F x ∈ nhds x | null | true |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isPartial._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.RecKind → Sort u} →
(t : Lean.Elab.RecKind) → motive Lean.Elab.RecKind.partial → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
TensorialAt.mkHom₂ | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | {𝕜 : 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} →
{M : Type u_4} →
... | Given an `A`-valued operation `Φ` on sections of vector bundles `V` and `V'` which is tensorial
at `x` in each argument, the construction `TensorialAt.mkHom₂` provides the associated continuous
linear map `V x →L[𝕜] V' x →L[𝕜] A`. | true |
zpow_one_add | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ (1 + n) = a * a ^ n | null | true |
Subbimodule.mk._proof_5 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {M : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | null | false |
Absorbs.zero | Mathlib.Topology.Bornology.Absorbs | ∀ {M : Type u_1} {E : Type u_2} [inst : Bornology M] [inst_1 : Zero E] [inst_2 : SMulZeroClass M E] {s : Set E},
0 ∈ s → Absorbs M s 0 | null | true |
InformationTheory.klDiv_of_not_ac | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
¬μ.AbsolutelyContinuous ν → InformationTheory.klDiv μ ν = ⊤ | null | true |
MeasureTheory.Measure.haarMeasure_eq_iff | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [SecondCountableTopology G]
(K₀ : TopologicalSpace.PositiveCompacts G) (μ : MeasureTheory.Measure G) [MeasureTheory.SigmaFinite μ]
[μ.IsMulLeftInvariant], MeasureThe... | Let `μ` be a σ-finite left invariant measure on `G`. Then `μ` is equal to the Haar measure
defined by `K₀` iff `μ K₀ = 1`. | true |
FreeMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : Monoid M] (f : FreeMonoid α →* M), FreeMonoid.lift (⇑f ∘ FreeMonoid.of) = f | null | true |
Filter.tendsto_atTop_atBot_of_antitone | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone f → (∀ (b : β), ∃ a, f a ≤ b) → Filter.Tendsto f Filter.atTop Filter.atBot | null | true |
String.append_left_inj | Init.Data.String.Defs | ∀ {s₁ s₂ : String} (t : String), s₁ ++ t = s₂ ++ t ↔ s₁ = s₂ | null | true |
TwoUniqueSums.of_addOpposite | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} [inst : Add G], TwoUniqueSums Gᵃᵒᵖ → TwoUniqueSums G | null | true |
CategoryTheory.Cat.HasLimits.limitConeX_str | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat),
(CategoryTheory.Cat.HasLimits.limitConeX F).str = inferInstance | null | true |
_private.Mathlib.Tactic.Inclusion.Extension.Interval.0.Inclusion.Interval.mem_Icc_of_le._proof_1_2 | Mathlib.Tactic.Inclusion.Extension.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α} {I J : Inclusion.Interval α},
a ∈ I → a ≤ x → x ≤ b → b ∈ J → x ∈ Inclusion.Interval.Icc I.lb J.ub | null | false |
Function.Injective.starMul._proof_2 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} {S : Type u_2} (f : R → S) [inst : Star R] [inst_1 : Mul R] [inst_2 : Mul S] [inst_3 : StarMul S]
(hf : Function.Injective f) (star : ∀ (x : R), f (star x) = star (f x)),
(∀ (x y : R), f (x * y) = f x * f y) → ∀ (x y : R), Star.star (x * y) = Star.star y * Star.star x | null | false |
Lean.Meta.Grind.ParentSet.mk | Lean.Meta.Tactic.Grind.Types | List Lean.Expr → Lean.Meta.Grind.ParentSet | null | true |
Monoid.CoprodI.NeWord.head.eq_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 j k : ι) (_hne : j ≠ k)
(w₁ : Monoid.CoprodI.NeWord M x j) (w₂ : Monoid.CoprodI.NeWord M k x_1), (w₁.append _hne w₂).head = w₁.head | null | true |
UniqueProds.casesOn | Mathlib.Algebra.Group.UniqueProds.Basic | {G : Type u_1} →
[inst : Mul G] →
{motive : UniqueProds G → Sort u} →
(t : UniqueProds G) →
((uniqueMul_of_nonempty :
∀ {A B : Finset G}, A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueMul A B a0 b0) →
motive ⋯) →
motive t | null | false |
Lean.Meta.Grind.EMatchTheoremPtr | Lean.Meta.Tactic.Grind.EMatchTheoremPtr | Type | null | true |
Set.Ici.coe_sup._simp_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a : α} [inst : SemilatticeSup α] {x y : ↑(Set.Ici a)}, ↑x ⊔ ↑y = ↑(x ⊔ y) | null | false |
_private.Init.Data.String.Defs.0.String.utf8ByteSize_eq_zero_iff._simp_1_1 | Init.Data.String.Defs | ∀ {s t : String}, (s = t) = (s.toByteArray = t.toByteArray) | null | false |
FirstOrder.Language.Relations.formula₂.eq_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u'} (r : L.Relations 2) (t₁ t₂ : L.Term α), r.formula₂ t₁ t₂ = r.formula ![t₁, t₂] | null | true |
Lean.Compiler.LCNF.Simp.simpProj? | Lean.Compiler.LCNF.Simp.SimpValue | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure →
OptionT Lean.Compiler.LCNF.Simp.SimpM (Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) | Try to simplify projections `.proj _ i s` where `s` is constructor.
| true |
MeasureTheory.Lp.zero_smul | Mathlib.MeasureTheory.Function.Holder | ∀ {α : Type u_1} (𝕜 : Type u_3) {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (p : ENNReal)
{q r : ENNReal} [hpqr : p.HolderTriple q r] [inst : NormedRing 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E] (f : ↥(MeasureTheory.Lp E q μ)), 0 • f = 0 | null | true |
_private.Init.Data.AC.0.Lean.Data.AC.removeNeutrals.loop.match_1.eq_1 | Init.Data.AC | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | null | true |
_private.Lean.Compiler.ExportAttr.0.Lean.isValidCppName | Lean.Compiler.ExportAttr | Lean.Name → Bool | null | true |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso_inv_pullbackHom_assoc | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰.affineRefinement.openCover).I₀)
{Z : AlgebraicGeometry.Scheme} (h : 𝒰.affineRefinement.openCover.X i ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.OpenCover.pullba... | null | true |
CategoryTheory.Limits.pullbackRightPullbackFstIso_hom_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (f' : W ⟶ X)
[inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : CategoryTheory.Limits.HasPullback f' (CategoryTheory.Limits.pullback.fst f g)] {Z_1 : C} (h : Y ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Categor... | null | true |
CategoryTheory.Limits.coequalizerComparison_map_desc_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f g : X ⟶ Y) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D)
[inst_2 : CategoryTheory.Limits.HasEqualizer f g] [inst_3 : CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)]
{Z : C} {h : Z ⟶ X} (w :... | null | false |
_private.Mathlib.RingTheory.HahnSeries.Basic.0.HahnSeries.ext.match_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} {inst : PartialOrder Γ} {inst_1 : Zero R} (motive : HahnSeries Γ R → Prop)
(h : HahnSeries Γ R),
(∀ (coeff : Γ → R) (isPWO_support' : (Function.support coeff).IsPWO),
motive { coeff := coeff, isPWO_support' := isPWO_support' }) →
motive h | null | false |
MeasureTheory.Measure.IsOpenPosMeasure.mk | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} {μ : MeasureTheory.Measure X},
(∀ (U : Set X), IsOpen U → U.Nonempty → μ U ≠ 0) → μ.IsOpenPosMeasure | null | true |
Denumerable.nat | Mathlib.Basic.Denumerable | Denumerable ℕ | null | true |
Std.Time.DateTime.ofLocalDateWithZone | Std.Time.Zoned | Std.Time.PlainDate → Std.Time.TimeZone → Std.Time.DateTime | Converts a `PlainDate` to a `DateTime` using `TimeZone`.
| true |
groupHomology.single_isCycle₁_of_mem_fixedPoints | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A] (g : G),
∀ a ∈ MulAction.fixedPoints G A, groupHomology.IsCycle₁ fun₀ | g => a | null | true |
_private.Init.Data.Option.Monadic.0.Option.instForIn'InferInstanceMembershipOfMonad.match_1.eq_1 | Init.Data.Option.Monadic | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (r : β) (h_1 : (r : β) → motive (ForInStep.done r))
(h_2 : (r : β) → motive (ForInStep.yield r)),
(match ForInStep.done r with
| ForInStep.done r => h_1 r
| ForInStep.yield r => h_2 r) =
h_1 r | null | true |
_private.Init.Data.Int.LemmasAux.0.Int.ble'_eq_true._proof_1_2 | Init.Data.Int.LemmasAux | ∀ (a a_1 : ℕ), ¬Int.negSucc a_1 < ↑a → False | null | false |
LightCondensed.finYoneda._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u_1)) (X : FintypeCatᵒᵖ),
(TypeCat.ofHom fun g => g ∘ ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X).unop)) =
CategoryTheory.CategoryStruct.id
((Opposite.unop X).obj → F.obj (FintypeCat.toLightProfinite.op.obj (Opposite.op ↧PUn... | null | false |
submonoidOfIdempotent._proof_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_1} [inst : LeftCancelMonoid M] (S : Set M), S * S = S → ∀ a ∈ S, ∀ (n : ℕ), a ^ (n + 1) ∈ S | null | false |
RootPairing.exist_set_root_not_disjoint_and_le_ker_coroot'_of_invtSubmodule | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [NeZero 2]
[IsDomain R] [Module.IsTorsionFree R M] (q : Submodule R M),
(∀ (i : ι), q ∈ Module.End.invtSubmodu... | null | true |
_private.Mathlib.RingTheory.FiniteType.0.AddMonoidAlgebra.finiteType_iff_fg._simp_1_1 | Mathlib.RingTheory.FiniteType | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊤) = True | null | false |
MeasureTheory.integrableOn_indicator_iff | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε' : Type u_4} {mα : MeasurableSpace α} {s t : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε'] [inst_1 : ESeminormedAddMonoid ε'] {f : α → ε'},
MeasureTheory.NullMeasurableSet s μ →
(MeasureTheory.IntegrableOn (s.indicator f) t μ ↔ MeasureTheory.IntegrableOn f (s ∩ t) μ) | null | true |
SimpleGraph.Walk.IsPath.of_append_left | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w}, (p.append q).IsPath → p.IsPath | null | true |
Lean.Meta.Grind.traceEMatchDiagsCompact | Lean.Meta.Tactic.Grind.Main | Lean.PArray Lean.Meta.Grind.EMatchDiagInfo → Lean.Meta.Grind.GrindM Unit | null | true |
Lean.mkIntDvd | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | Given `a b : Int`, returns `a ∣ b` | true |
MulActionHom.comp_inverse' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{φ' : N → M} {f : X →ₑ[φ] Y} {g : Y → X} {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
{h₁ : Function.LeftInverse g ⇑f} {h₂ : Function.RightInverse g ⇑f}, (f.inverse' g k₂ h₁ h₂).comp... | null | true |
eVariationOn.eVariationOn_inter_Ioi_eq_inter_Ici_of_continuousWithinAt | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {M : Type u_3} [inst_1 : PseudoEMetricSpace M] [inst_2 : TopologicalSpace α]
[OrderTopology α] {f : α → M} {s : Set α} {a : α},
(nhdsWithin a (s ∩ Set.Ioi a)).NeBot →
ContinuousWithinAt f (s ∩ Set.Ici a) a → eVariationOn f (s ∩ Set.Ioi a) = eVariationOn f (s ∩ Set.Ici a) | If a function is continuous on the right at a point `a`, then its variations on
`Ioi a` and on `Ici a` coincide. We give a version relative to a set `s`. | true |
Finset.addEnergy_pos | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Add α] {s t : Finset α}, s.Nonempty → t.Nonempty → 0 < s.addEnergy t | null | true |
ModuleCat.hom_surjective | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R}, Function.Surjective ModuleCat.Hom.hom | Convenience shortcut for `ModuleCat.hom_bijective.surjective`. | true |
Matroid.IsCircuit.eq_of_superset_isCircuit | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C C' : Set α}, M.IsCircuit C → M.IsCircuit C' → C' ⊆ C → C = C' | null | true |
Lean.Core.SavedState.messages._inherited_default | Lean.CoreM | Lean.MessageLog | null | false |
Prod.insthasUniqueDiv | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddMonoid M] [inst_1 : AddMonoid N] [HasUniqueDiv M] [HasUniqueDiv N],
HasUniqueDiv (M × N) | null | true |
Algebra.ctorIdx | Mathlib.Algebra.Algebra.Defs | {R : Type u} → {A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → Algebra R A → ℕ | null | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation._proof_2 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (I.precomp g).Y) (I.precomp g).f =
CategoryTheory.CategoryStruct.comp g I.f | null | false |
Locale.localePointOfSpacePoint._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ (X : Type u_1) [inst : TopologicalSpace X] (x : X), (x ∈ ⊤) = (x ∈ ⊤) | null | false |
IsDivSequence | Mathlib.Data.Nat.DvdSequence | {α : Type u_1} → {β : Type u_2} → [Dvd α] → [Dvd β] → (α → β) → Prop | **Alias** of `IsDvdSequence`.
---
A function `f : α → β` is a divisibility sequence if `a ∣ b` implies `f a ∣ f b`. | true |
_private.Mathlib.Analysis.Complex.Norm.0.Complex.abs_re_div_norm_le_one._simp_1_1 | Mathlib.Analysis.Complex.Norm | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
Convex.openSegment_interior_closure_subset_interior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] {s : Set E},
Convex 𝕜 s → ∀ {x y : E}, x ∈ interior s → y ∈ closure s → openSegment 𝕜 x y ⊆ interior s | null | true |
Order.PFilter.infGi | Mathlib.Order.PFilter | {P : Type u_1} →
[inst : CompleteSemilatticeInf P] →
GaloisCoinsertion (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F) | If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. | true |
CategoryTheory.Functor.whiskerRight | Mathlib.CategoryTheory.Whiskering | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
{G H : CategoryTheory.Functor C D} → (G ⟶ H) → (F : CategoryTheory.Functor D E) → G.comp... | If `α : G ⟶ H` then `whiskerRight α F : G ⋙ F ⟶ H ⋙ F` has components `F.map (α.app X)`. | true |
OrderHom.instFunLike._proof_1 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f g : α →o β), f.toFun = g.toFun → f = g | null | false |
Std.DTreeMap.Internal.Impl.contains_inter_eq_false_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false → Std.DTreeMap.Internal.Impl.contains k (m₁.inter m₂ ⋯) = false | null | true |
CategoryTheory.ShortComplex.HomologyData.ofIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂), CategoryTheory.IsIso e.hom.τ₂ | null | false |
Equiv.ofIff._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {P Q : Prop} (h : P ↔ Q) (x : P), ⋯ = ⋯ | null | false |
CategoryTheory.whiskeringLeftCompEvaluation_inv_app | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (a : A)
(X : CategoryTheory.Functor B C),
(CategoryTheory.whiskeringLeftCompEvaluation F a).inv.app X... | null | true |
Lean.Meta.Sym.Offset.recOn | Lean.Meta.Sym.Offset | {motive : Lean.Meta.Sym.Offset → Sort u} →
(t : Lean.Meta.Sym.Offset) →
((k : ℕ) → motive (Lean.Meta.Sym.Offset.num k)) →
((e : Lean.Expr) → (k : ℕ) → motive (Lean.Meta.Sym.Offset.add e k)) → motive t | null | false |
_private.Mathlib.Analysis.Complex.Exponential.0.Real.exp_approx_end._simp_1_2 | Mathlib.Analysis.Complex.Exponential | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
MeromorphicOn.logDeriv_mul_eventuallyEq | Mathlib.Analysis.Meromorphic.LogDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {f g : 𝕜 → 𝕜'} {U : Set 𝕜},
MeromorphicOn f U →
MeromorphicOn g U →
(∀ x ∈ U, meromorphicOrderAt f x ≠ ⊤) →
(∀ x ∈ U, meromorphicOrderAt g x ≠ ⊤) → logDe... | The logarithmic derivative converts products into sums: away from a codiscrete subset of `U`, the
logarithmic derivative of a product of two meromorphic functions is the sum of the logarithmic
derivatives.
| true |
Topology.WithGeneratedByTopology.instTopologicalSpace | Mathlib.Topology.Convenient.GeneratedBy | {ι : Type t} →
{X : ι → Type u} →
[inst : (i : ι) → TopologicalSpace (X i)] →
{Y : Type v} → [inst_1 : TopologicalSpace Y] → TopologicalSpace (Topology.WithGeneratedByTopology X Y) | null | true |
CategoryTheory.ObjectProperty.instIsClosedUnderColimitsOfShapeOppositeOpOfIsClosedUnderLimitsOfShape | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [P.IsClosedUnderLimitsOfShape J], P.op.IsClosedUnderColimitsOfShape Jᵒᵖ | null | true |
Lean.Parser.Command.catBehaviorBoth | Lean.Parser.Syntax | Lean.Parser.Parser | null | true |
MeasureTheory.Measure.haveLebesgueDecomposition_add | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) | null | true |
Inner.noConfusion | Mathlib.Analysis.InnerProductSpace.Defs | {P : Sort u} →
{𝕜 : Type u_4} →
{E : Type u_5} →
{t : Inner 𝕜 E} →
{𝕜' : Type u_4} → {E' : Type u_5} → {t' : Inner 𝕜' E'} → 𝕜 = 𝕜' → E = E' → t ≍ t' → Inner.noConfusionType P t t' | null | false |
CategoryTheory.Localization.Preadditive.add'_map | 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 |
Std.CancellationToken.State.mk | Std.Sync.CancellationToken | Option Std.CancellationReason → Std.Queue Std.CancellationToken.Consumer → Std.CancellationToken.State | null | true |
_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_of_spec | Mathlib.Data.Nat.MaxPowDiv | ∀ {p k n a b : ℕ}, 1 < p → n ≠ 0 → p ^ a * b = n → ¬p ∣ b → (p ^ k ∣ n ↔ k ≤ a) | null | true |
Set.exists_ne_of_one_lt_ncard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, 1 < s.ncard → ∀ (a : α), ∃ b ∈ s, b ≠ a | null | true |
Order.isPredPrelimitRecOn._proof_4 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} (b : α) [inst : PartialOrder α] [inst_1 : PredOrder α] (hb : ¬Order.IsPredPrelimit b),
¬IsMin (Classical.choose ⋯) | null | false |
BitVec.instDecidableForallBitVec._f | Init.Data.BitVec.Decidable | (x : ℕ) →
Nat.below (motive := fun x => (x_1 : BitVec x → Prop) → DecidablePred x_1 → Decidable (∀ (v : BitVec x), x_1 v)) x →
(x_1 : BitVec x → Prop) → DecidablePred x_1 → Decidable (∀ (v : BitVec x), x_1 v) | null | false |
Preorder.toGradeBoundedOrder._proof_1 | Mathlib.Order.Grade | ∀ {α : Type u_1} [inst : Preorder α] (x x_1 : α), x ⋖ x_1 → x ⋖ x_1 | null | false |
AddConstMap.instAddConstMapClass | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H},
AddConstMapClass (AddConstMap G H a b) G H a b | null | true |
Ultrafilter.comap._proof_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_1} {β : Type u_2} {m : α → β} (u : Ultrafilter β), Set.range m ∈ u → (Filter.comap m ↑u).NeBot | null | false |
Lean.Grind.CommRing.Expr.toPolyC.go._sparseCasesOn_1 | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} →
(t : Lean.Grind.CommRing.Expr) →
((k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k)) →
((i : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var i)) →
(Nat.hasNotBit 9 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.DocString.Formatter.0.Lean.Doc.Parser.versoSyntaxToString | Lean.DocString.Formatter | Lean.Syntax → String | null | true |
_private.Mathlib.FieldTheory.AbelRuffini.0.solvableByRad.eq_1 | Mathlib.FieldTheory.AbelRuffini | ∀ (F : Type u_1) (E : Type u_2) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
solvableByRad F E = sInf {s | ∀ (x : E) (n : ℕ), n ≠ 0 → x ^ n ∈ s → x ∈ s} | null | true |
UpperSet.coe_iSup._simp_2 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → UpperSet α), ⋂ i, ↑(f i) = ↑(⨆ i, f i) | null | false |
List.headI_dedup | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Inhabited α] (l : List α),
l.dedup.headI = if l.headI ∈ l.tail then l.tail.dedup.headI else l.headI | null | true |
WithLp.prod_dist_eq_of_L2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
(x y : WithLp 2 (α × β)), dist x y = √(dist x.fst y.fst ^ 2 + dist x.snd y.snd ^ 2) | null | true |
Pi.constAlgHom._proof_4 | Mathlib.Algebra.Algebra.Pi | ∀ (A : Type u_1) (B : Type u_2) [inst : Semiring B] (x y : B),
(↑↑(Pi.constRingHom A B)).toFun (x + y) = (↑↑(Pi.constRingHom A B)).toFun x + (↑↑(Pi.constRingHom A B)).toFun y | null | false |
Hamming.instModule._proof_2 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_1} (α : Type u_3) [inst : Semiring α] (β : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (β i)]
[inst_2 : (i : ι) → Module α (β i)] (b : Hamming β), 1 • b = b | null | false |
_private.Mathlib.RingTheory.PicardGroup.0.Module.Invertible.bijective_self_of_surjective._simp_1_2 | Mathlib.RingTheory.PicardGroup | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | null | false |
Matrix.vecMulBilin | Mathlib.LinearAlgebra.Matrix.ToLin | {m : Type u_1} →
{n : Type u_2} →
(R : Type u_3) →
(S : Type u_4) →
{A : Type u_5} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : Module R A] →
[inst_4 : Module S A] →
... | `Matrix.vecMul` as a bilinear map.
When `A` is non-commutative, this can be instantiated as `vecMulBilin A Aᵐᵒᵖ` | true |
ContravariantClass | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | (M : Type u_1) → (N : Type u_2) → (M → N → N) → (N → N → Prop) → Prop | Given an action `μ` of a Type `M` on a Type `N` and a relation `r` on `N`, informally, the
`ContravariantClass` says that "if the result of the action `μ` on a pair satisfies the
relation `r`, then the initial pair satisfied the relation `r`."
More precisely, the `ContravariantClass` is a class taking two Types `M N`,... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.