name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.DocumentColorParams.workDoneToken?._inherited_default | Lean.Data.Lsp.LanguageFeatures | Option Lean.Lsp.ProgressToken | null | false |
_private.Std.Data.DHashMap.Internal.HashesTo.0.Std.DHashMap.Internal.List.HashesTo.containsKey_eq_false._simp_1_1 | Std.Data.DHashMap.Internal.HashesTo | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α},
(Std.Internal.List.containsKey a l = true) = ∃ p ∈ l, (p.fst == a) = true | null | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizePattern.go._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Internalize | {motive : Lean.Meta.Grind.Origin → Sort u} →
(t : Lean.Meta.Grind.Origin) →
((declName : Lean.Name) → motive (Lean.Meta.Grind.Origin.decl declName)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
variationOnFromTo | Mathlib.Topology.EMetricSpace.BoundedVariation | {α : Type u_1} → [LinearOrder α] → {E : Type u_2} → [PseudoEMetricSpace E] → (α → E) → Set α → α → α → ℝ | The **signed** variation of `f` on the interval `Icc a b` intersected with the set `s`,
squashed to a real (therefore only really meaningful if the variation is finite)
| true |
Lean.Parser.Category.prec | Init.Notation | Lean.Parser.Category | `prec` is a builtin syntax category for precedences. A precedence is a value
that expresses how tightly a piece of syntax binds: for example `1 + 2 * 3` is
parsed as `1 + (2 * 3)` because `*` has a higher precedence than `+`.
Higher numbers denote higher precedence.
In addition to literals like `37`, there are some spe... | true |
Additive.subtractionMonoid._proof_1 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (x : Additive α), - -x = x | null | false |
MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_sum_measure | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {s : Finset ι} {t : ι → Set α},
(∀ i ∈ s, MeasureTheory.NullMeasurableSet (t i) μ) →
μ Set.univ < ∑ i ∈ s, μ (t i) → ∃ i ∈ s, ∃ j ∈ s, ∃ (_ : i ≠ j), (t i ∩ t j).Nonempty | Pigeonhole principle for measure spaces: if `s` is a `Finset` and
`∑ i ∈ s, μ (t i) > μ univ`, then one of the intersections `t i ∩ t j` is not empty. | true |
Aesop.runFirstNormRule | Aesop.Search.Expansion.Norm | Lean.MVarId →
Aesop.UnorderedArraySet Lean.MVarId →
Array (Aesop.IndexMatchResult Aesop.NormRule) → Aesop.NormM (Option (Aesop.DisplayRuleName × Aesop.NormRuleResult)) | null | true |
FundamentalGroupoid.nonempty_iff._simp_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (X : Type u_3), Nonempty (FundamentalGroupoid X) = Nonempty X | null | false |
CategoryTheory.Limits.botSquareIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{Y₃ Y₂ Y₁ X₃ : C} →
{g₂ : Y₃ ⟶ Y₂} →
{g₁ : Y₂ ⟶ Y₁} →
{i₃ : Y₃ ⟶ X₃} →
{t₁ : CategoryTheory.Limits.PushoutCocone g₂ i₃} →
{i₂ : Y₂ ⟶ t₁.pt} →
(t₂ : CategoryTheory.Limits.PushoutCocone g₁ i₂... | Given
```
Y₃ - i₃ -> X₃
| |
g₂ f₂
∨ ∨
Y₂ - i₂ -> X₂
| |
g₁ f₁
∨ ∨
Y₁ - i₁ -> X₁
```
The bottom square is a pushout if the top square and the big square are.
| true |
Std.TreeSet.Raw.insert | Std.Data.TreeSet.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet.Raw α cmp → α → Std.TreeSet.Raw α cmp | Creates a new empty tree set. It is also possible and recommended to
use the empty collection notations `∅` and `{}` to create an empty tree set. `simp` replaces
`empty` with `∅`.
| true |
List.min?_eq_some_iff_subtype | Init.Data.List.MinMax | ∀ {α : Type u_1} {a : α} [inst : Min α] [inst_1 : LE α] {xs : List α} [inst_2 : Std.MinEqOr α]
[Std.IsLinearOrder { x // x ∈ xs }] [Std.LawfulOrderMin { x // x ∈ xs }], xs.min? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, a ≤ b | null | true |
String.Slice.foldl_eq_foldl_toList | Init.Data.String.Lemmas.Iterate | ∀ {α : Type u} {f : α → Char → α} {init : α} {s : String.Slice},
String.Slice.foldl f init s = List.foldl f init s.copy.toList | null | true |
Nat.perfect_iff_sum_properDivisors | Mathlib.NumberTheory.Divisors | ∀ {n : ℕ}, 0 < n → (n.Perfect ↔ ∑ i ∈ n.properDivisors, i = n) | null | true |
Finset.disjSups_empty_left | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] [inst_2 : OrderBot α]
[inst_3 : DecidableRel Disjoint] {t : Finset α}, ∅.disjSups t = ∅ | null | true |
CategoryTheory.Functor.instLaxMonoidalMonMapAddMon._proof_6 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.BraidedCategory C]
[inst_5 : CategoryThe... | null | false |
_private.Mathlib.Order.Filter.AtTopBot.ModEq.0.Nat.frequently_even._simp_1_1 | Mathlib.Order.Filter.AtTopBot.ModEq | ∀ {n : ℕ}, Even n = (n % 2 = 0) | null | false |
EMetric.hausdorffEdist_union_le | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s₁ s₂ t₁ t₂ : Set α},
Metric.hausdorffEDist (s₁ ∪ s₂) (t₁ ∪ t₂) ≤ max (Metric.hausdorffEDist s₁ t₁) (Metric.hausdorffEDist s₂ t₂) | **Alias** of `Metric.hausdorffEDist_union_le`. | true |
Decidable.rec | Init.Prelude | {p : Prop} →
{motive : Decidable p → Sort u} →
((h : ¬p) → motive (isFalse h)) → ((h : p) → motive (isTrue h)) → (t : Decidable p) → motive t | null | false |
ContDiffAt.hasStrictDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {n : WithTop ℕ∞} {𝕂 : Type u_1} [inst : RCLike 𝕂] {F' : Type u_3} [inst_1 : NormedAddCommGroup F']
[inst_2 : NormedSpace 𝕂 F'] {f : 𝕂 → F'} {x : 𝕂}, ContDiffAt 𝕂 n f x → n ≠ 0 → HasStrictDerivAt f (deriv f x) x | If a function is `C^n` with `1 ≤ n` around a point, then the derivative of `f` at this point
is also a strict derivative. | true |
Lean.Grind.Linarith.zero_ne_one_of_charC | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.Linarith.Context α)
(p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.zero_ne_one_of_charC_cert c p = true →
Lean.Grind.Linarith.Var.denote ctx 0 = One.one → Lean.Grind.Linarith.Poly.denote' ctx p ≠ 0 | null | true |
NNReal.coe_multiset_prod | Mathlib.Data.NNReal.Basic | ∀ (s : Multiset NNReal), ↑s.prod = (Multiset.map NNReal.toReal s).prod | null | true |
SModEq.bot | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
x ≡ y [SMOD ⊥] ↔ x = y | null | true |
imp_congr_left | Init.Core | ∀ {a b c : Prop}, (a ↔ b) → (a → c ↔ b → c) | null | true |
ContinuousOn.div₀ | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀] [ContinuousInv₀ G₀]
[ContinuousMul G₀] {f g : α → G₀} [inst_4 : TopologicalSpace α] {s : Set α},
ContinuousOn f s → ContinuousOn g s → (∀ x ∈ s, g x ≠ 0) → ContinuousOn (fun x => f x / g x) s | null | true |
Nonneg.zero._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α], 0 ≤ 0 | null | false |
CategoryTheory.Presieve.bind | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(S : CategoryTheory.Presieve X) →
(⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y) → CategoryTheory.Presieve X | Given a presieve `S` on `X`, and presieve `R` on `Y` for each
`f : Y ⟶ X` in `S`, produce a presieve on `X`:
`{ g ≫ f | (f : Y ⟶ X) ∈ S, (g : Z ⟶ Y) ∈ R f }`.
| true |
HasSum.tsum_fiberwise | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [IsUniformAddGroup α]
[CompleteSpace α] [T2Space α] {f : β → α} {a : α},
HasSum f a → ∀ (g : β → γ), HasSum (fun c => ∑' (b : ↑(g ⁻¹' {c})), f ↑b) a | null | true |
_private.Mathlib.Algebra.Star.LinearMap.0.LinearMap.IntrinsicStar.isSelfAdjoint_iff_map_star._simp_1_3 | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u} [inst : InvolutiveStar R] {r s : R}, (star r = s) = (star s = r) | null | false |
FourierInvModule.toFourierTransformInv | Mathlib.Analysis.Fourier.Notation | {R : Type u_5} →
{E : Type u_6} →
{F : outParam (Type u_7)} →
[inst : Add E] →
[inst_1 : Add F] → [inst_2 : SMul R E] → [inst_3 : SMul R F] → FourierInvModule R E F → FourierTransformInv E F | null | true |
PadicInt.nonarchimedean | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℤ_[p]), ‖q + r‖ ≤ max ‖q‖ ‖r‖ | null | true |
_private.Mathlib.Algebra.Module.Presentation.Basic.0.Module.Relations.Solution.surjective_fromQuotient_iff_surjective_π._simp_1_1 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M), solution.π = solution.fromQuotient ∘ₗ relations.toQuotient | null | false |
EisensteinSeries.isLittleO_const_left_of_properSpace_of_discreteTopology | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {α : Type u_1} (a : α) [inst : NormedAddCommGroup α] [DiscreteTopology α] [ProperSpace α],
(fun x => a) =o[Filter.cofinite] fun x => ‖x‖ | null | true |
_private.Mathlib.NumberTheory.FLT.Basic.0.fermatLastTheoremWith_of_fermatLastTheoremWith_coprime._simp_1_1 | Mathlib.NumberTheory.FLT.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b ≠ 0) = (a ≠ 0 ∧ b ≠ 0) | null | false |
Int.toArray_roo_eq_singleton | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, n = m + 2 → (m<...n).toArray = #[m + 1] | null | true |
StandardSubspace.mulI._proof_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] (S : StandardSubspace H),
S.toClosedSubmodule.mulI ⊓ S.toClosedSubmodule.mulI.mulI = ⊥ | null | false |
differentiableAt_comp_const_sub | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {a b : 𝕜},
DifferentiableAt 𝕜 (fun x => f (b - x)) a ↔ DifferentiableAt 𝕜 f (b - a) | null | true |
Quaternion.instIsStarNormal | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), IsStarNormal a | null | true |
MeasureTheory.Measure.IsNegInvariant.recOn | Mathlib.MeasureTheory.Group.Measure | {G : Type u_1} →
[inst : MeasurableSpace G] →
[inst_1 : Neg G] →
{μ : MeasureTheory.Measure G} →
{motive : μ.IsNegInvariant → Sort u} →
(t : μ.IsNegInvariant) → ((neg_eq_self : μ.neg = μ) → motive ⋯) → motive t | null | false |
ContinuousMap.Homotopy.comp._proof_2 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_3} {Y : Type u_2} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Y, Z)} (G : g₀.Homotopy g₁) (F : f₀.Homotopy f₁) (x : X),
G ((0, x).1, F (0, x)) = (g₀.comp f₀) x | null | false |
Lean.Widget.TaggedText.forM._unsafe_rec | Lean.Widget.TaggedText | {m : Type → Type u_1} →
{α : Type u_2} → [Monad m] → (α → Lean.Widget.TaggedText α → m Unit) → Lean.Widget.TaggedText α → m Unit | null | false |
_private.Mathlib.Tactic.ITauto.0.Mathlib.Tactic.ITauto.search._sparseCasesOn_16 | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.IProp → Sort u} →
(t : Mathlib.Tactic.ITauto.IProp) →
((a a_1 : Mathlib.Tactic.ITauto.IProp) → motive (a.or a_1)) → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Equiv.Set.rangeInl.match_3 | Mathlib.Logic.Equiv.Set | ∀ (α : Type u_1) (β : Type u_2) (motive : ↑(Set.range Sum.inl) → Prop) (x : ↑(Set.range Sum.inl)),
(∀ (val : α), motive ⟨Sum.inl val, ⋯⟩) → motive x | null | false |
Hyperreal.isSt_refl_real | Mathlib.Analysis.Real.Hyperreal | ∀ (r : ℝ), (↑r).IsSt r | null | true |
Aesop.Subgoal.diff | Aesop.RuleTac.Basic | Aesop.Subgoal → Aesop.GoalDiff | A diff between the goal the rule was run on and this goal. Many `MetaM`
tactics report information that allows you to easily construct a `GoalDiff`.
If you don't have access to such information, use `diffGoals`, but note that
it may not give optimal results.
| true |
Nat.bodd_one | Mathlib.Data.Nat.Bits | Nat.bodd 1 = true | null | true |
Subgroup.inclusion_inj | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (h : H ≤ K) {x y : ↥H},
(Subgroup.inclusion h) x = (Subgroup.inclusion h) y ↔ x = y | null | true |
Metric.Snowflaking.isBounded_image_ofSnowflaking_iff._simp_1 | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : Bornology X] {s : Set (Metric.Snowflaking X α hα₀ hα₁)},
Bornology.IsBounded (⇑Metric.Snowflaking.ofSnowflaking '' s) = Bornology.IsBounded s | null | false |
HopfAlgCat.instMonoidalCategoryStruct | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | (R : Type u) → [inst : CommRing R] → CategoryTheory.MonoidalCategoryStruct (HopfAlgCat R) | null | true |
Continuous.of_neg | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous (-f) → Continuous f | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Affine.0.AlgebraicGeometry.isAffine_of_isAffineOpen_basicOpen._simp_1_2 | Mathlib.AlgebraicGeometry.Morphisms.Affine | ∀ {R : CommRingCat} (f : ↑R),
PrimeSpectrum.basicOpen f =
(AlgebraicGeometry.Spec R).basicOpen
((CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.ΓSpecIso R).inv) f) | null | false |
BialgEquiv.ofBialgHom._proof_3 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
CStarMatrix.instSMul._aux_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} → {R : Type u_4} → {A : Type u_3} → [SMul R A] → R → CStarMatrix m n A → CStarMatrix m n A | null | false |
Lean.Meta.CaseArraySizesSubgoal | Lean.Meta.Match.CaseArraySizes | Type | null | true |
Ordinal.type_sum_lex | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
Ordinal.type (Sum.Lex r s) = Ordinal.type r + Ordinal.type s | null | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.needsExplicit._sparseCasesOn_4 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) →
motive Lean.BinderInfo.implicit →
motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 10 t.ctorIdx → motive t) → motive t | null | false |
Algebra.Generators.toExtension_σ | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Generators R S ι) (a : S), P.toExtension.σ a = P.σ a | null | true |
RootPairing.restrictScalars'._proof_5 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_5} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_2)
[inst_5 : Field K] [inst_6 : Algebra K L] [inst_7 : Module K M] [inst_8 : Module K N] [inst_9 : IsSc... | null | false |
Batteries.BinomialHeap.Imp.HeapNode.rankTR.go | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} → Batteries.BinomialHeap.Imp.HeapNode α → ℕ → ℕ | Computes `s.rank + r` | true |
QuotientAddGroup.lift.eq_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_4} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
(φ : G →+ M) (HN : N ≤ φ.ker), QuotientAddGroup.lift N φ HN = (QuotientAddGroup.con N).lift φ ⋯ | null | true |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_2 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules) (f : (↑R)ᵒᵖ),
IsLocalizedModule.Away (Opposite.unop f)
(ModuleCat.Hom.hom
(AlgebraicGeometry.tilde.toOpen ((AlgebraicGeometry.modulesSpecToSheaf.obj M).obj.obj (Opposite.op ⊤))
(PrimeSpectrum.basicOpen (Opposite.unop f)))... | null | false |
_private.Mathlib.AlgebraicGeometry.ZariskisMainTheorem.0.AlgebraicGeometry.Scheme.Hom.exists_mem_and_isIso_morphismRestrict_toNormalization._simp_1_2 | Mathlib.AlgebraicGeometry.ZariskisMainTheorem | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsOpenImmersion f]
[inst_1 : AlgebraicGeometry.IsOpenImmersion g],
(AlgebraicGeometry.Scheme.Hom.opensFunctor g).obj (AlgebraicGeometry.Scheme.Hom.opensRange f) =
AlgebraicGeometry.Scheme.Hom.opensRange (CategoryTheory.Catego... | null | false |
Set.eq_top_of_card_le_of_finite | Mathlib.SetTheory.Cardinal.NatCard | ∀ {α : Type u_1} [Finite α] {s : Set α}, Nat.card α ≤ Nat.card ↑s → s = ⊤ | null | true |
PadicInt.continuousAddCharEquiv.match_1 | Mathlib.NumberTheory.Padics.AddChar | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
(R : Type u_1) →
[inst_1 : NormedRing R] →
(motive : { κ // Continuous ⇑κ } → Sort u_2) →
(x : { κ // Continuous ⇑κ }) → ((κ : AddChar ℤ_[p] R) → (hκ : Continuous ⇑κ) → motive ⟨κ, hκ⟩) → motive x | null | false |
Lean.Widget.RpcEncodablePacket.range?._@.Lean.Widget.UserWidget.3433604829._hygCtx._hyg.1 | Lean.Widget.UserWidget | Lean.Widget.RpcEncodablePacket✝ → Option Lean.Json | null | false |
Continuous.rpow | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f g : α → ℝ},
Continuous f → Continuous g → (∀ (x : α), f x ≠ 0 ∨ 0 < g x) → Continuous fun x => f x ^ g x | null | true |
CategoryTheory.SmallObject.SuccStruct.Iteration.casesOn | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
{Φ : CategoryTheory.SmallObject.SuccStruct C} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : CategoryTheory.Limits.HasIterationOfShape J C] →
... | null | false |
Std.Http.Chunk.instDecidableEqExtensionValue | Std.Http.Data.Chunk | DecidableEq Std.Http.Chunk.ExtensionValue | null | true |
_private.Init.Omega.LinearCombo.0.Lean.Omega.instToStringInt.match_1 | Init.Omega.LinearCombo | (motive : ℤ → Sort u_1) → (x : ℤ) → ((m : ℕ) → motive (Int.ofNat m)) → ((m : ℕ) → motive (Int.negSucc m)) → motive x | null | false |
AddSubmonoid.subPairs.eq_1 | Mathlib.GroupTheory.MonoidLocalization.DivPairs | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (f : ⊤.LocalizationMap G)
(s : AddSubmonoid G), AddSubmonoid.subPairs f s = AddSubmonoid.comap (subAddMonoidHom.comp ((↑f).prodMap ↑f)) s | null | true |
Cardinal.toNat_strictMonoOn | Mathlib.SetTheory.Cardinal.ToNat | StrictMonoOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0) | null | true |
Lean.Server.CodeActionResolveData.noConfusion | Lean.Server.CodeActions.Basic | {P : Sort u} →
{t t' : Lean.Server.CodeActionResolveData} → t = t' → Lean.Server.CodeActionResolveData.noConfusionType P t t' | null | false |
PFunctor.M.IsBisimulation.mk | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {R : F.M → F.M → Prop},
(∀ {a a' : F.A} {f : F.B a → F.M} {f' : F.B a' → F.M}, R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a', f'⟩) → a = a') →
(∀ {a : F.A} {f f' : F.B a → F.M},
R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a, f'⟩) → ∀ (i : F.B a), R (f i) (f' i)) →
PFunctor.M.IsB... | null | true |
CategoryTheory.Limits.IsInitial.subsingleton_to | Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C}
(hI : CategoryTheory.Limits.IsInitial I) {A : C}, Subsingleton (A ⟶ I) | null | true |
List.rdrop.eq_1 | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (l : List α) (n : ℕ), l.rdrop n = List.take (l.length - n) l | null | true |
List.perm_cons_append_cons | Init.Data.List.Perm | ∀ {α : Type u_1} {l l₁ l₂ : List α} (a : α), l.Perm (l₁ ++ l₂) → (a :: l).Perm (l₁ ++ a :: l₂) | null | true |
CategoryTheory.Mod.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Mod | {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.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : Cat... | null | false |
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.size_mkSlice_rco._simp_1_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α}, Std.Slice.size xs = (Std.Slice.toList xs).length | null | false |
_private.Aesop.Forward.State.0.Aesop.VariableMap.modifyM.match_1 | Aesop.Forward.State | {α : Type u_1} →
(motive : Aesop.InstMap × α → Sort u_2) →
(__discr : Aesop.InstMap × α) → ((m : Aesop.InstMap) → (a : α) → motive (m, a)) → motive __discr | null | false |
Equiv.Finset.union_symm_right | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} (h : Disjoint s t) {i : α} (hi : i ∈ t) (hi' : i ∈ s ∪ t),
(Equiv.Finset.union s t h).symm ⟨i, hi'⟩ = Sum.inr ⟨i, hi⟩ | null | true |
Nat.succ.elim | Init.Prelude | {motive : ℕ → Sort u} → (t : ℕ) → t.ctorIdx = 1 → ((n : ℕ) → motive n.succ) → motive t | null | false |
Lean.Lsp.DocumentSymbolAux.children?._default | Lean.Data.Lsp.LanguageFeatures | {Self : Type} → Option (Array Self) | null | false |
Diffeomorph.coe_refl | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_5} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_9)
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (n : WithTop ℕ∞), ⇑(Diffeomorph.refl I ... | null | true |
UInt8.ofNat_eq_iff_mod_eq_toNat | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt8), UInt8.ofNat a = b ↔ a % 2 ^ 8 = b.toNat | null | true |
Plausible.Random.instBoundedRandomFin | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {n : ℕ} → Plausible.BoundedRandom m (Fin n) | null | true |
WithTop.LinearOrderedAddCommGroup.instLinearOrderedAddCommGroupWithTopOfIsOrderedAddMonoid._proof_8 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G], WithTop.map (fun a => -a) ⊤ = ⊤ | null | false |
_private.Init.Data.List.Sort.Impl.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [... | null | true |
CategoryTheory.MorphismProperty.map_mem_map | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(P : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y),
P f → P.map F (F.map f) | null | true |
Std.DTreeMap.Internal.RxoIterator._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) →
(β : α → Type v) →
{inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Std.DTreeMap.Internal.RxoIterator α β) | null | false |
CategoryTheory.PreZeroHypercover.Hom._sizeOf_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{S : C} →
{E : CategoryTheory.PreZeroHypercover S} → {F : CategoryTheory.PreZeroHypercover S} → [SizeOf C] → E.Hom F → ℕ | null | false |
OpenPartialHomeomorph.subtypeRestr_target_subset | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : TopologicalSpace.Opens X} (hs : Nonempty ↥s),
(e.subtypeRestr hs).target ⊆ e.target | null | true |
_private.Mathlib.Order.Monotone.Basic.0.not_monotone_not_antitone_iff_exists_lt_lt._simp_1_1 | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β},
(¬Monotone f ∧ ¬Antitone f) = ∃ a b c, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) | null | false |
_private.Mathlib.Geometry.Manifold.Riemannian.Basic.0.setOf_riemannianEDist_lt_subset_nhds._simp_1_3 | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {r : NNReal}, (0 < ↑r) = (0 < r) | null | false |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_14 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : ↥(Unitization.unitsFstOne R A)),
⟨{
val :=
1 +
↑(PreQuasiregular.equiv.symm
↑{ val := PreQuasi... | null | false |
Nat.preimage_Iic | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R},
0 ≤ a → Nat.cast ⁻¹' Set.Iic a = Set.Iic ⌊a⌋₊ | null | true |
CategoryTheory.Abelian.Ext.mapExactFunctor._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Map | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u_4}
[inst_2 : CategoryTheory.Category.{u_2, u_4} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
[F.Additive], F.PreservesZeroMorphisms | null | false |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.iUnion_Ioc_right._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b | null | false |
Finset.smul_finset_univ | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {a : α}
[inst_3 : Fintype β], a • Finset.univ = Finset.univ | null | true |
TensorialAt.mkHom._proof_6 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
Std.DHashMap.Internal.Raw₀.contains_of_contains_union_of_contains_eq_false_right | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, (m₁.union m₂).contains k = true → m₂.contains k = false → m₁.contains k = true | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.