name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Finsupp.equivFunOnFinite | Mathlib.Data.Finsupp.Defs | {α : Type u_1} → {M : Type u_4} → [inst : Zero M] → [Finite α] → (α →₀ M) ≃ (α → M) | Given `Finite α`, `equivFunOnFinite` is the `Equiv` between `α →₀ β` and `α → β`.
(All functions on a finite type are finitely supported.) | true |
Lean.Elab.ConfigEval.foldConfigM._unsafe_rec | Lean.Elab.ConfigEval.Basic | {α : Type} →
{m : Type → Type} →
[Monad m] →
[Lean.MonadRef m] → α → Lean.Syntax → (α → Lean.Elab.ConfigEval.ConfigItem → m α) → (α → Lean.Syntax → m α) → m α | null | false |
SimpleGraph.ConnectedComponent.map_mk | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G →g G') (v : V),
SimpleGraph.ConnectedComponent.map φ (G.connectedComponentMk v) = G'.connectedComponentMk (φ v) | null | true |
Set.bounded_le_inter_lt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Bounded (fun x1 x2 => x1 ≤ x2) (s ∩ {b | a < b}) ↔ Set.Bounded (fun x1 x2 => x1 ≤ x2) s | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.TacticData.mctxBefore | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.TacticData✝ → Lean.MetavarContext | MetavarContext before the tactic | true |
ProofWidgets.instToJsonRpcEncodablePacket.toJson._@.ProofWidgets.Data.Html.2463204861._hygCtx._hyg.58 | ProofWidgets.Data.Html | ProofWidgets.RpcEncodablePacket✝ → Lean.Json | null | false |
LinearGrowth.linearGrowthInf_iInf | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {ι : Type u_1} [Finite ι] (u : ι → ℕ → EReal),
LinearGrowth.linearGrowthInf (⨅ i, u i) = ⨅ i, LinearGrowth.linearGrowthInf (u i) | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj.match_1.eq_2 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (motive : AugmentedSimplexCategory → AugmentedSimplexCategory → Sort u_1) (x : AugmentedSimplexCategory)
(h_1 : (m n : SimplexCategory) → motive (CategoryTheory.WithInitial.of m) (CategoryTheory.WithInitial.of n))
(h_2 : (x : AugmentedSimplexCategory) → motive CategoryTheory.WithInitial.star x)
(h_3 : (x : Augm... | null | true |
Array.instOrientedOrd | Init.Data.Order.Ord | ∀ {α : Type u_1} [inst : Ord α] [Std.OrientedOrd α], Std.OrientedOrd (Array α) | null | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity.mkProof.match_1 | Lean.Meta.CongrTheorems | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs fst_1 snd : Lean.Expr) → motive (some (fst, lhs, fst_1, snd))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
Std.Internal.List.length_le_length_insertListConst | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)},
l.length ≤ (Std.Internal.List.insertListConst l toInsert).length | null | true |
Path.target' | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (self : Path x y), self.toFun 1 = y | The end point of a `Path`. | true |
LinearMap.toMatrixRight'_id | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {m : Type u_3} [inst_1 : Fintype m] [inst_2 : DecidableEq m],
LinearMap.toMatrixRight' LinearMap.id = 1 | null | true |
Even.pow_nonneg | Mathlib.Algebra.Order.Ring.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : LinearOrder R] [IsOrderedRing R] [ExistsAddOfLE R] {n : ℕ},
Even n → ∀ (a : R), 0 ≤ a ^ n | null | true |
differentiableAt_of_isInvertible_fderiv | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, (fderiv 𝕜 f x).IsInvertible → DifferentiableAt 𝕜 f ... | null | true |
Std.DHashMap.Internal.Raw₀.equiv_iff_toList_perm_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m₁ m₂ : Std.DHashMap.Raw α β), m₁.Equiv m₂ ↔ m₁.toList.Perm m₂.toList | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_eq_findIdxNth_add._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n s : ℕ},
n + 1 ≤ (List.findIdxs p (head :: tail) s).length → n < (List.findIdxs p (head :: tail) s).length | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_66 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length},
(head == x) = true → (List.idxsOf x (head :: tail) s)[0] - s < (head :: tail).length | null | false |
Polynomial.MonicDegreeEq.degree | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] [Nontrivial R] (p : Polynomial.MonicDegreeEq R n), (↑p).degree = ↑n | null | true |
selfAdjoint.instNNRatCast._proof_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (q : ℚ≥0), IsSelfAdjoint ↑q | null | false |
Array.count_eq_zero_of_not_mem | Init.Data.Array.Count | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {xs : Array α}, a ∉ xs → Array.count a xs = 0 | null | true |
Lean.Server.RequestCancellationToken._sizeOf_inst | Lean.Server.RequestCancellation | SizeOf Lean.Server.RequestCancellationToken | null | false |
Set.countable_iUnion_iff._simp_1 | Mathlib.Data.Set.Countable | ∀ {α : Type u} {ι : Sort x} [Countable ι] {t : ι → Set α}, (⋃ i, t i).Countable = ∀ (i : ι), (t i).Countable | null | false |
DirectLimit.instGroup._proof_5 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → Group (G i)] ... | null | false |
MeasureTheory.Lp._proof_4 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ (E : Type u_1) [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | null | false |
Nat.ceilRoot_eq_zero | Mathlib.Data.Nat.Factorization.Root | ∀ {a n : ℕ}, n.ceilRoot a = 0 ↔ n = 0 ∨ a = 0 | null | true |
HahnModule.instAddCommGroup._proof_12 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommGroup V]
(a b : HahnModule Γ R V), a + b = b + a | null | false |
AddSubgroupClass.subtype_injective | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_4} (H : S) [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G],
Function.Injective ⇑↑H | null | true |
FiberwiseLinear.openPartialHomeomorph._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.FiberwiseLinear | ∀ {𝕜 : Type u_3} {B : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {U : Set B} (φ : B → F ≃L[𝕜] F),
∀ _x ∈ U ×ˢ Set.univ, (_x.1, (φ _x.1).symm _x.2) ∈ U ×ˢ Set.univ | null | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.IsLindelof.elim_nhds_subcover._simp_1_5 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
ValuativeRel.supp._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : ValuativeRel R] {a b : R},
a ∈ {x | x ≤ᵥ 0} → b ∈ {x | x ≤ᵥ 0} → a + b ≤ᵥ 0 | null | false |
Set.Ioo_sub_one_left_eq_Ioc | Mathlib.Algebra.Order.Interval.Set.SuccPred | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : One α] [inst_2 : Sub α] [PredSubOrder α] [NoMinOrder α] (a b : α),
Set.Ioo (a - 1) b = Set.Ico a b | null | true |
LieModule.nontrivial_lowerCentralSeriesLast | Mathlib.Algebra.Lie.Nilpotent | ∀ (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] [LieModule R L M] [Nontrivial M]
[LieModule.IsNilpotent L M], Nontrivial ↥(LieModule.lowerCentralSeriesLast R L M) | null | true |
FractionalIdeal.map_coeIdeal | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{P' : Type u_3} [inst_3 : CommRing P'] [inst_4 : Algebra R P'] (g : P →ₐ[R] P') (I : Ideal R),
FractionalIdeal.map g ↑I = ↑I | null | true |
Std.DHashMap.Internal.Raw₀.get!ₘ_eq_getValueCast! | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
{m : Std.DHashMap.Internal.Raw₀ α β},
Std.DHashMap.Internal.Raw.WFImp ↑m →
∀ {a : α} [inst_3 : Inhabited (β a)],
m.get!ₘ a = Std.Internal.List.getValueCast! a (Std.DHashMap.Internal.toListModel (↑m).buckets) | null | true |
Std.ExtTreeSet.get?_max? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α},
t.max? = some km → t.get? km = some km | null | true |
_private.Init.Data.Array.Find.0.Array.of_findIdx?_eq_some.match_1.splitter | Init.Data.Array.Find | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x | null | true |
CategoryTheory.Functor.Monoidal.ε_η | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {D : Type u₂}
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory D}
(F : CategoryTheory.Functor C D) [self : F.Monoidal],
CategoryTheory.CategoryStruct.comp (CategoryTheory... | null | true |
FirstOrder.Field.FieldAxiom.toSentence.eq_9 | Mathlib.ModelTheory.Algebra.Field.Basic | FirstOrder.Field.FieldAxiom.existsPairNE.toSentence =
(((FirstOrder.Language.var ∘ Sum.inr) 0).bdEqual ((FirstOrder.Language.var ∘ Sum.inr) 1)).not.ex.ex | null | true |
SeparationQuotient.t2Space_iff | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} [inst : TopologicalSpace X], T2Space (SeparationQuotient X) ↔ R1Space X | null | true |
BitVec.getLsbD_ofBool | Init.Data.BitVec.Lemmas | ∀ (b : Bool) (i : ℕ), (BitVec.ofBool b).getLsbD i = (decide (i = 0) && b) | null | true |
Submodule.span_singleton_mul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A}
{p : Submodule R A}, (R ∙ x) * p = x • p | null | true |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_12 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (x₁ x₂ y₂ : ℕ), y₂ ≤ x₁ → y₂ ≤ x₂ → x₁ - y₂ = x₂ - y₂ → x₁ = x₂ | null | false |
div_self_eq_one₀._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, (a / a = 1) = (a ≠ 0) | null | false |
HNNExtension.NormalWord.TransversalPair.noConfusion | Mathlib.GroupTheory.HNNExtension | {P : Sort u} →
{G : Type u_1} →
{inst : Group G} →
{A B : Subgroup G} →
{t : HNNExtension.NormalWord.TransversalPair G A B} →
{G' : Type u_1} →
{inst' : Group G'} →
{A' B' : Subgroup G'} →
{t' : HNNExtension.NormalWord.TransversalPair G' A' B'} →
... | null | false |
_private.Mathlib.Probability.Independence.Basic.0.ProbabilityTheory.iIndepFun_iff._simp_1_2 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.iIndep m μ =
∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, MeasurableSet (f i)) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i) | null | false |
Std.Roo.toList_eq_match_rco | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α],
r.toList =
match Std.PRange.succ? r.lower with
| none => []
| some ... | null | true |
Simps.ProjectionData.mk._flat_ctor | Mathlib.Tactic.Simps.Basic | Lean.Name → Lean.Expr → List ℕ → Bool → Bool → Simps.ProjectionData | null | false |
_private.Std.Data.String.ToNat.0.String.Slice.isNat_iff'._simp_1_1 | Std.Data.String.ToNat | ∀ {a b : Bool}, ((!a) = b) = (a = !b) | null | false |
SchwartzMap.smulRightCLM._proof_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} (F : Type u_2) {G : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
(L : E →L[ℝ] G →L[ℝ] ℝ) (f g : SchwartzMap E F) (x : E),
(L x).smulRight ((f + g) x) = (L x)... | null | false |
BitVec.getElem_eq_true_of_lt_of_le | Init.Data.BitVec.Lemmas | ∀ {w k : ℕ} {x : BitVec w} (hk' : k < w), x.toNat < 2 ^ (k + 1) → 2 ^ k ≤ x.toNat → x[k] = true | If a bitvector interpreted as a natural number is strictly smaller than `2 ^ (k + 1)` and greater than or
equal to 2 ^ k, then the bit at position `k` must be `true` | true |
Complex.instCoeReal | Mathlib.Data.Complex.Basic | Coe ℝ ℂ | null | true |
Std.Iterators.Types.FilterMap.mk.inj | Init.Data.Iterators.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} {lift : ⦃α : Type w⦄ → m α → n α}
{f : β → Std.Iterators.PostconditionT n (Option γ)} {inner inner_1 : Std.IterM m β},
{ inner := inner } = { inner := inner_1 } → inner = inner_1 | null | true |
Subalgebra.instSubringClass | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
SubringClass (Subalgebra R A) A | null | true |
iSupIndep.linearEquiv_symm_apply | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {N : Type u_6} [inst : DecidableEq ι] [inst_1 : Ring R] [inst_2 : AddCommGroup N]
[inst_3 : Module R N] {p : ι → Submodule R N} (ind : iSupIndep p) (iSup_top : ⨆ i, p i = ⊤) {i : ι} {x : N}
(h : x ∈ p i), (ind.linearEquiv iSup_top).symm x = fun₀ | i => ⟨x, h⟩ | null | true |
Metric.ediam_image_le_iff | Mathlib.Topology.EMetricSpace.Diam | ∀ {α : Type u_1} {X : Type u_2} [inst : PseudoEMetricSpace X] {d : ENNReal} {f : α → X} {s : Set α},
Metric.ediam (f '' s) ≤ d ↔ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) ≤ d | null | true |
_private.Mathlib.Topology.UnitInterval.0.unitInterval.image_coe_preimage_symm._simp_1_1 | Mathlib.Topology.UnitInterval | Function.Involutive unitInterval.symm = True | null | false |
Dense.exists_seq_strictAnti_tendsto_of_lt | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[FirstCountableTopology α] {s : Set α},
Dense s →
∀ {x y : α}, x < y → ∃ u, StrictAnti u ∧ (∀ (n : ℕ), u n ∈ Set.Ioo x y ∩ s) ∧ Filter.Tendsto u Filter.atTop (nhds x) | null | true |
HahnSeries.SummableFamily.instAddCommGroup | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
{α : Type u_5} →
[inst : PartialOrder Γ] → [inst_1 : AddCommGroup R] → AddCommGroup (HahnSeries.SummableFamily Γ R α) | null | true |
_private.Mathlib.Data.Quot.0.Quot.surjective_lift.match_1_1 | Mathlib.Data.Quot | ∀ {α : Sort u_1} {γ : Sort u_2} {f : α → γ} (y : γ) (motive : (∃ a, f a = y) → Prop) (x : ∃ a, f a = y),
(∀ (x : α) (hx : f x = y), motive ⋯) → motive x | null | false |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_6 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {F : Type u_8} {M : Type u_9} {X : Type u_10} {Y : Type u_11} [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y] [MulActionHomClass F M X Y] (f : F) (c : M) (x : X), c • f x = f (c • x) | null | false |
Real.one_le_exp | Mathlib.Analysis.Complex.Exponential | ∀ {x : ℝ}, 0 ≤ x → 1 ≤ Real.exp x | null | true |
withSeminorms_iInf | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{κ : ι → Type u_11} {p : (i : ι) → SeminormFamily 𝕜 E (κ i)} {t : ι → TopologicalSpace E},
(∀ (i : ι), WithSeminorms (p i)) → WithSeminorms (SeminormFamily.sigma p) | null | true |
with_gaugeSeminormFamily | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] [inst_4 : Module ℝ E] [inst_5 : IsScalarTower ℝ 𝕜 E] [inst_6 : ContinuousSMul ℝ E]
[IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] [LocallyConvexSpace 𝕜 E], WithSeminorms (gaugeSemino... | The topology of a locally convex space is induced by the gauge seminorm family. | true |
ergodic_mul_left_of_denseRange_zpow | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[SecondCountableTopology G] [BorelSpace G] {g : G},
(DenseRange fun x => g ^ x) →
∀ (μ : MeasureTheory.Measure G) [MeasureTheory.IsFiniteMeasure μ] [μ.InnerRegular] [μ.IsMulLeftInvariant],
E... | null | true |
Language.map | Mathlib.Computability.Language | {α : Type u_1} → {β : Type u_2} → (α → β) → Language α →+* Language β | Maps the alphabet of a language. | true |
_private.Lean.Parser.Attr.0.Lean.Parser.Attr.specialize._regBuiltin.Lean.Parser.Attr.specialize.parenthesizer_11 | Lean.Parser.Attr | IO Unit | null | false |
Polynomial.iterate_derivative_mul | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] {n : ℕ} (p q : Polynomial R),
(⇑Polynomial.derivative)^[n] (p * q) =
∑ k ∈ Finset.range n.succ, n.choose k • ((⇑Polynomial.derivative)^[n - k] p * (⇑Polynomial.derivative)^[k] q) | null | true |
CategoryTheory.Functor.mapArrowEquivalence._proof_2 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (e : C ≌ D) (X : CategoryTheory.Arrow C),
CategoryTheory.CategoryStruct.comp
(e.functor.mapArrow.map (((CategoryTheory.Functor.mapArrowFunctor C C).mapIso e.unitIso).hom.app X))
... | null | false |
List.cyclicPermutations_of_ne_nil | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l : List α),
l ≠ [] → l.cyclicPermutations = (List.zipWith (fun x1 x2 => x1 ++ x2) l.tails l.inits).dropLast | null | true |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.ruzsaSzemerediNumberNat_asymptotic_lower_bound._simp_1_2 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
IsCoprime.isRelPrime | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {a b : R}, IsCoprime a b → IsRelPrime a b | null | true |
Submonoid.unitsEquivUnitsType._proof_6 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) (x x_1 : ↥S.units),
(match x * x_1 with
| ⟨val, h⟩ =>
{ val := ⟨(Units.coeHom M) val, ⋯⟩, inv := ⟨(Units.coeHom M) val⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ }) =
match x * x_1 with
| ⟨val, h⟩ => { val := ⟨(Units.coeHom M) val, ⋯⟩, inv := ⟨(Units.coeHo... | null | false |
PresheafOfModules.instAddCommGroupModuleColimit._proof_20 | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{cR : CategoryTheory.Limits.Cocone R} (hcR : CategoryTheory.Limits.IsColimit cR) {M : PresheafOfModules R}
{cM : CategoryTheory.Limits.Cocone M.presheaf} (hcM : CategoryTheory.Limits.IsColimit cM),
autoParam
... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.CircleMap.0.eq_of_circleMap_eq._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | (Complex.I = 0) = False | null | false |
List.mem_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {as : List α}, x ∈ as.reverse ↔ x ∈ as | null | true |
_private.Mathlib.RingTheory.Valuation.Basic.0.Valuation.IsEquiv.valueGroup₀Fun_spec._simp_1_2 | Mathlib.RingTheory.Valuation.Basic | ∀ {α : Type u} {a b : α}, (↑a = ↑b) = (a = b) | null | false |
Std.DTreeMap.Raw.WF.emptyc | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, ∅.WF | null | true |
finsum_eq_indicator_apply | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M) (a : α),
∑ᶠ (_ : a ∈ s), f a = s.indicator f a | null | true |
CommBialgCat._sizeOf_1 | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → {inst : CommRing R} → [SizeOf R] → CommBialgCat R → ℕ | null | false |
_private.Mathlib.NumberTheory.Padics.PadicIntegers.0.PadicInt.coe_sum._simp_1_1 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (self : ↥(PadicInt.subring p)), ↑self = PadicInt.Coe.ringHom self | null | false |
Lean.Elab.Term.LetIdDeclView.binders | Lean.Elab.Binders | Lean.Elab.Term.LetIdDeclView → Array Lean.Syntax | null | true |
UpperSemicontinuousOn.add | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {γ : Type u_5} [inst_1 : AddCommMonoid γ]
[inst_2 : LinearOrder γ] [IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ] [OrderTopology γ] [ContinuousAdd γ]
{f g : α → γ}, UpperSemicontinuousOn f s → UpperSemicontinuousOn g s → UpperSemicontinuousOn (fun z => ... | The sum of two upper semicontinuous functions is upper semicontinuous. Formulated with
`[ContinuousAdd]`. The primed version of the lemma uses an explicit continuity assumption on
addition, for application to `EReal`. | true |
_private.Init.Data.List.Pairwise.0.List.Pairwise.imp.match_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} (motive : (x : List α) → List.Pairwise R x → Prop) (x : List α)
(x_1 : List.Pairwise R x),
(∀ (a : Unit), motive [] ⋯) →
(∀ (a : α) (l : List α) (h₁ : ∀ a' ∈ l, R a a') (h₂ : List.Pairwise R l), motive (a :: l) ⋯) → motive x x_1 | null | false |
Lean.Name.MatchUpToIndexSuffix.suffixMatch.elim | Batteries.Lean.Meta.UnusedNames | {motive : Lean.Name.MatchUpToIndexSuffix → Sort u} →
(t : Lean.Name.MatchUpToIndexSuffix) →
t.ctorIdx = 2 → ((i : ℕ) → motive (Lean.Name.MatchUpToIndexSuffix.suffixMatch i)) → motive t | null | false |
Int64.ofIntLE_eq_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : Int64.minValue.toInt ≤ x} {h₂ : x ≤ Int64.maxValue.toInt}, Int64.ofIntLE x h₁ h₂ = Int64.ofIntClamp x | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodingStepAux.match_5 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((n : Lean.Name) → (i : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj n i struct)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((mvarId : ... | null | false |
Stream'.Seq.update_cons_succ | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (f : α → α) (n : ℕ),
(Stream'.Seq.cons hd tl).update (n + 1) f = Stream'.Seq.cons hd (tl.update n f) | null | true |
Mathlib.Explode.Entry.type | Mathlib.Tactic.Explode.Datatypes | Mathlib.Explode.Entry → Lean.MessageData | A type of this expression as a `MessageData`. Make sure to use `addMessageContext`. | true |
_private.Mathlib.Analysis.Normed.Affine.Simplex.0.Affine.Simplex.scalene_reindex_iff._proof_1_8 | Mathlib.Analysis.Normed.Affine.Simplex | ∀ {m n : ℕ} (e : Fin (m + 1) ≃ Fin (n + 1)) (fst snd : Fin (m + 1)) (property : fst < snd),
e fst < e snd →
(e.symm (↑(if h : e fst < e snd then ⟨(e fst, e snd), ⋯⟩ else ⟨(e snd, e fst), ⋯⟩)).1,
e.symm (↑(if h : e fst < e snd then ⟨(e fst, e snd), ⋯⟩ else ⟨(e snd, e fst), ⋯⟩)).2).1 <
(e.symm (↑(if... | null | false |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.instAddGroup._simp_6 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a b : G →₀ k},
{ toFinsupp := a } + { toFinsupp := b } = { toFinsupp := a + b } | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.denom_aux | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ (A B : Matrix.SpecialLinearGroup (Fin 2) ℤ) (z : UpperHalfPlane),
↑(↑(A * B) 1 0) *
UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) B)) ↑z =
↑(↑A 1 0) * ↑(↑B).det +
↑(↑B 1 0) *
UpperHalfPlane.denom
(Matrix.SpecialLinearGroup... | null | true |
Lean.Elab.Tactic.Omega.Fact.mk.sizeOf_spec | Lean.Elab.Tactic.Omega.Core | ∀ (coeffs : Lean.Omega.Coeffs) (constraint : Lean.Omega.Constraint)
(justification : Lean.Elab.Tactic.Omega.Justification constraint coeffs),
sizeOf { coeffs := coeffs, constraint := constraint, justification := justification } =
1 + sizeOf coeffs + sizeOf constraint + sizeOf justification | null | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.nhdsWithin_bot.match_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (x : ℝ) (x_1 : EReal) (motive : x_1 ∈ Set.Ioc ⊥ ↑x → Prop) (x_2 : x_1 ∈ Set.Ioc ⊥ ↑x),
(∀ (h1 : ⊥ < x_1) (h2 : x_1 ≤ ↑x), motive ⋯) → motive x_2 | null | false |
Set.image_sub_const_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => x - a) '' Set.uIcc b c = Set.uIcc (b - a) (c - a) | null | true |
WeierstrassCurve.natDegree_Φ_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [Nontrivial R] {n : ℤ}, n ≠ 0 → 0 < (W.Φ n).natDegree | null | true |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalUnaryUInt8 | Lean.Meta.Sym.Simp.EvalGround | (UInt8 → UInt8) → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | null | true |
SSet.Truncated.HomotopyCategory.homMk_comp_homMk_assoc | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2}
{x₀ x₁ x₂ : V.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 })}
{e₀₁ : SSet.Truncated.Edge x₀ x₁} {e₁₂ : SSet.Truncated.Edge x₁ x₂} {e₀₂ : SSet.Truncated.Edge x₀ x₂}
(h : e₀₁.CompStruct e₁₂ e₀₂) {Z : V.HomotopyCategory} (h : SSet.Truncated.HomotopyCatego... | null | true |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkNoConfusion.match_1 | Lean.Meta.AppBuilder | (motive : Option (Lean.ConstructorVal × Array Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.ConstructorVal × Array Lean.Expr)) →
((ctorB : Lean.ConstructorVal) → (ys2 : Array Lean.Expr) → motive (some (ctorB, ys2))) →
((x : Option (Lean.ConstructorVal × Array Lean.Expr)) → motive x) → motive __do_lift | null | false |
LibraryNote.continuity_lemma_statement | Mathlib.Topology.Continuous | Batteries.Util.LibraryNote | The library contains many lemmas stating that functions/operations are continuous. There are many
ways to formulate the continuity of operations. Some are more convenient than others.
Note: for the most part this note also applies to other properties
(`Measurable`, `Differentiable`, `ContinuousOn`, ...).
### The tradi... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.