name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalConvConvSeq._regBuiltin.Lean.Elab.Tactic.Conv.evalConvConvSeq_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
_private.Mathlib.Analysis.Analytic.Composition.0.HasFPowerSeriesWithinAt.comp._simp_1_1 | Mathlib.Analysis.Analytic.Composition | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c < min a b) = (c < a ∧ c < b) | null | false |
ZeroAtInftyContinuousMap.unitizationEquiv_mul | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : R1Space X] [inst_2 : TopologicalSpace R]
[inst_3 : CommRing R] [inst_4 : IsTopologicalRing R] (f g : Unitization R (ZeroAtInftyContinuousMap X R)),
(ZeroAtInftyContinuousMap.unitizationEquiv X R) (f * g) =
(ZeroAtInftyContinuousMap.unitizatio... | null | true |
instSubsingleton | Init.Core | ∀ (p : Prop), Subsingleton p | null | true |
Complex.isAlgebraic_sin_rat_mul_pi | Mathlib.NumberTheory.Niven | ∀ (q : ℚ), IsAlgebraic ℤ (Complex.sin (↑q * ↑Real.pi)) | `sin(q * π)` for `q : ℚ` is algebraic over `ℤ`, using the complex `sin` function. | true |
Pi.evalNonUnitalRingHom._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_2} (f : I → Type u_1) [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (i : I) (x y : (i : I) → f i),
(↑(Pi.evalAddMonoidHom f i)).toFun (x + y) =
(↑(Pi.evalAddMonoidHom f i)).toFun x + (↑(Pi.evalAddMonoidHom f i)).toFun y | null | false |
CategoryTheory.Cokleisli.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Kleisli | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {U : CategoryTheory.Comonad C} → C → CategoryTheory.Cokleisli U | null | false |
ContDiffBump.rOut | Mathlib.Analysis.Calculus.BumpFunction.Basic | {E : Type u_1} → {c : E} → ContDiffBump c → ℝ | real numbers `0 < rIn < rOut` | true |
CuspForm.instAddCommGroup._proof_5 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ},
autoParam (∀ (n : ℕ) (x : CuspForm Γ k), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
NormedAddCommGroup.ofCoreReplaceTopology._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : Norm E]
[T : TopologicalSpace E] (core : NormedSpace.Core 𝕜 E) (H : T = PseudoEMetricSpace.toUniformSpace.toTopologicalSpace)
{x y : E}, dist x y = 0 → x = y | null | false |
ContinuousLinearEquiv.summable | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_4} {R : Type u_6} {R₂ : Type u_7} {M : Type u_8} {M₂ : Type u_9} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
[inst_5 : Module R₂ M₂] [inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace M₂] {σ : R →+* R₂} {σ' : R₂ →+* R}
... | null | true |
Std.HashSet.Raw.Equiv.of_forall_contains_eq | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [LawfulBEq α],
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ | null | true |
FreeAddMonoid.casesOn_zero | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {motive : FreeAddMonoid α → Sort u_6} (zero : motive 0)
(of_add : (x : α) → (xs : FreeAddMonoid α) → motive (FreeAddMonoid.of x + xs)),
FreeAddMonoid.casesOn 0 zero of_add = zero | null | true |
ContinuousMap.coeFnRingHom_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Semiring β]
[inst_3 : IsTopologicalSemiring β] (f : C(α, β)) (a : α), ContinuousMap.coeFnRingHom f a = f a | null | true |
_private.Std.Sync.Broadcast.0.Std.Bounded.State.size | Std.Sync.Broadcast | {α : Type} → Std.Bounded.State✝ α → ℕ | Current number of messages stored in the circular buffer.
| true |
Vector.findFinIdx?_subtype | Init.Data.Vector.Find | ∀ {α : Type u_1} {n : ℕ} {p : α → Prop} {xs : Vector { x // p x } n} {f : { x // p x } → Bool} {g : α → Bool},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → Vector.findFinIdx? f xs = Vector.findFinIdx? g xs.unattach | null | true |
AffineIsometryEquiv._sizeOf_1 | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_4} →
{P : Type u_7} →
{P₂ : Type u_8} →
{inst : NormedField 𝕜} →
{inst_1 : SeminormedAddCommGroup V} →
{inst_2 : NormedSpace 𝕜 V} →
{inst_3 : PseudoMetricSpace P} →
{inst_4 : Norme... | null | false |
String.startsWith_toSlice | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.ForwardPattern pat] {s : String},
s.toSlice.startsWith pat = s.startsWith pat | null | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.Simp.SimpTheorems.2970893097._hygCtx._hyg.2 | Lean.Meta.Tactic.Simp.SimpTheorems | IO (IO.Ref Lean.Meta.SimpExtensionMap) | null | false |
Measurable.fun_neg | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : Neg G] [inst_1 : MeasurableSpace G] [MeasurableNeg G] {m : MeasurableSpace α}
{f : α → G}, Measurable f → Measurable fun i => -f i | null | true |
Lean.Lsp.DocumentFilter.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.DocumentFilter → Sort u} →
((language? scheme? pattern? : Option String) →
motive { language? := language?, scheme? := scheme?, pattern? := pattern? }) →
(t : Lean.Lsp.DocumentFilter) → motive t | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
Inner.noConfusionType | Mathlib.Analysis.InnerProductSpace.Defs | Sort u → {𝕜 : Type u_4} → {E : Type u_5} → Inner 𝕜 E → {𝕜' : Type u_4} → {E' : Type u_5} → Inner 𝕜' E' → Sort u | null | false |
PUnit.mulActionWithZero._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : MonoidWithZero R] (a : R), a • 0 = 0 | null | false |
RestrictedProduct.mapAlong_continuous | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι₁ : Type u_3} {ι₂ : Type u_4} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_6) [inst : (i : ι₁) → TopologicalSpace (R₁ i)]
[inst_1 : (i : ι₂) → TopologicalSpace (R₂ i)] {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} {A₁ : (i : ι₁) → Set (R₁ i)}
{A₂ : (i : ι₂) → Set (R₂ i)} (f : ι₂ → ι₁) (hf : Filter.Tendsto f 𝓕₂ 𝓕₁) (φ : (j : ... | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.Ici_nsmul_eq.match_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 | null | false |
Int8.shiftLeft | Init.Data.SInt.Basic | Int8 → Int8 → Int8 | Bitwise left shift for 8-bit signed integers. Usually accessed via the `<<<` operator.
Signed integers are interpreted as bitvectors according to the two's complement representation.
This function is overridden at runtime with an efficient implementation.
| true |
_private.Mathlib.Analysis.Analytic.CPolynomialDef.0.HasFiniteFPowerSeriesOnBall.eq_partialSum._simp_1_1 | Mathlib.Analysis.Analytic.CPolynomialDef | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Quiver.zigzagSetoid.match_1 | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_1) [inst : Quiver V] {x y : V} (motive : Nonempty (Quiver.Path x y) → Prop)
(x_1 : Nonempty (Quiver.Path x y)), (∀ (p : Quiver.Path x y), motive ⋯) → motive x_1 | null | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rcases.match_8 | Lean.Elab.Tactic.RCases | (motive : Option Lean.Ident × Lean.Syntax → Sort u_1) →
(x : Option Lean.Ident × Lean.Syntax) →
((hName? : Option Lean.Ident) → (tgt : Lean.Syntax) → motive (hName?, tgt)) → motive x | null | false |
MeasureTheory.withDensityᵥ_add | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] {f g : α → E},
MeasureTheory.Integrable f μ →
MeasureTheory.Integrable g μ → μ.withDensityᵥ (f + g) = μ.withDensityᵥ f + μ.withDensityᵥ g | null | true |
Set.fintypeOfFintypeImage | Mathlib.Data.Set.Finite.Basic | {α : Type u} →
{β : Type v} →
(s : Set α) → {f : α → β} → {g : β → Option α} → Function.IsPartialInv f g → [Fintype ↑(f '' s)] → Fintype ↑s | If a function `f` has a partial inverse `g` and the image of `s` under `f` is a set with
a `Fintype` instance, then `s` has a `Fintype` structure as well. | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullbackWithin_mlieBracketWithin_aux | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | null | true |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence_inverse_map_hom | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat))
(ι : Type u_1) [inst_1 : Unique ι] {X S : C} (f : X ⟶ S)
{X_1 Y : (CategoryTheory.Adjunction.ofCat (F.map f.op.toLoc).adj).t... | null | true |
AlgebraicGeometry.Scheme.range_fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | ∀ {X : AlgebraicGeometry.Scheme} (x : ↥X), Set.range ⇑(X.fromSpecResidueField x) = {x} | null | true |
MonoidAlgebra.mapDomainRingEquiv_apply | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Monoid N] (e : M ≃* N)
(x : MonoidAlgebra R M), ((MonoidAlgebra.mapDomainRingEquiv R e) x).coeff = Finsupp.equivMapDomain (↑e) x.coeff | **Alias** of `MonoidAlgebra.coeff_mapDomainRingEquiv`. | true |
Filter.Germ.coeRingHom | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {R : Type u_5} → [inst : Semiring R] → (l : Filter α) → (α → R) →+* l.Germ R | Coercion `(α → R) → Germ l R` as a `RingHom`. | true |
LSeries.logMul | Mathlib.NumberTheory.LSeries.Deriv | (ℕ → ℂ) → ℕ → ℂ | The (point-wise) product of `log : ℕ → ℂ` with `f`. | true |
Finset.card_inter_smul_inv | Mathlib.Combinatorics.Additive.Convolution | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G) (x : G),
(A ∩ x • B⁻¹).card = A.convolution B x | null | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.eq_zero_of_comapDomain_eq_zero._simp_1_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
intervalIntegral.intervalIntegral_pos_of_pos_on | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f : ℝ → ℝ} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b → (∀ x ∈ Set.Ioo a b, 0 < f x) → a < b → 0 < ∫ (x : ℝ) in a..b, f x | If `f : ℝ → ℝ` is integrable on `(a, b]` for real numbers `a < b`, and positive on the interior
of the interval, then its integral over `a..b` is strictly positive. | true |
Std.instCoeDepAnyAsyncStreamOfAsyncStream | Std.Sync.StreamMap | {t α : Type} → {x : t} → [Std.Async.IO.AsyncStream t α] → CoeDep t x (Std.AnyAsyncStream α) | null | true |
List.forall₂_nil_left_iff._simp_1 | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l : List β}, List.Forall₂ R [] l = (l = []) | null | false |
AddMonoidAlgebra.nonAssocSemiring.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddZeroClass M],
AddMonoidAlgebra.nonAssocSemiring =
{ toNonUnitalNonAssocSemiring := AddMonoidAlgebra.nonUnitalNonAssocSemiring, toOne := AddMonoidAlgebra.zero,
one_mul := ⋯, mul_one := ⋯, natCast := fun n => AddMonoidAlgebra.single 0 ↑n, natCas... | null | true |
_private.Mathlib.Data.List.Lattice.0.List.bagInter_sublist_left._proof_1_4 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l₁ l₂ : List α),
(l₁.bagInter (l₂.erase a)).Sublist l₁ → (a :: l₁.bagInter (l₂.erase a)).Sublist (a :: l₁) | null | false |
CategoryTheory.ShortComplex.SnakeInput.mono_L₀_f | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C) [CategoryTheory.Mono S.L₁.f], CategoryTheory.Mono S.L₀.f | null | true |
Localization.mk_eq_monoidOf_mk' | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M}, Localization.mk = (Localization.monoidOf S).mk' | null | true |
HomologicalComplex.homologyMap_inv._simp_1 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K L : HomologicalComplex C c} (φ : K ⟶ L) (i : ι) [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i] [inst_4 : CategoryTheory.IsIso φ],
HomologicalComplex.homo... | null | false |
Std.Sat.CNF.Clause.literals_erase | Std.Sat.CNF.Basic | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {c : Std.Sat.CNF.Clause α} {lit : Std.Sat.Literal α},
(c.erase lit).literals = List.filter (fun l => l != lit) c.literals | null | true |
lt_add_iff_pos_left._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {b : α} [inst : AddZeroClass α] [inst_1 : LT α] [AddRightStrictMono α] [AddRightReflectLT α] (a : α),
(a < b + a) = (0 < b) | null | false |
ImportGraph.Shake.Needs.instForInHighToLowProdNeedsKindNatOfMonad | ImportGraph.Shake.Basic | {m : Type → Type u_1} → [Monad m] → ForIn m ImportGraph.Shake.Needs.HighToLow (ImportGraph.Shake.NeedsKind × ℕ) | null | true |
ContinuousMapZero.nonUnitalStarAlgHom_postcomp._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ (X : Type u_2) {M : Type u_4} {R : Type u_3} {S : Type u_1} [inst : Zero X] [inst_1 : CommSemiring M]
[inst_2 : TopologicalSpace X] [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace S] [inst_5 : CommSemiring R]
[inst_6 : StarRing R] [inst_7 : IsTopologicalSemiring R] [inst_8 : CommSemiring S] [inst_9 : Sta... | null | false |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.singleton_le_singleton._simp_1_1 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Finset α} {a : α},
(toColex s ≤ toColex {a}) = ∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a) | null | false |
CategoryTheory.mono_iff_isIso_fst | Mathlib.CategoryTheory.Limits.EpiMono | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} {f : X ⟶ Y}
{c : CategoryTheory.Limits.PullbackCone f f} (hc : CategoryTheory.Limits.IsLimit c),
CategoryTheory.Mono f ↔ CategoryTheory.IsIso c.fst | null | true |
TwoUniqueProds.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_2} (G : ι → Type u_1) [inst : (i : ι) → Mul (G i)] [∀ (i : ι), TwoUniqueProds (G i)],
TwoUniqueProds ((i : ι) → G i) | null | true |
Std.HashMap.Raw.mem_of_mem_filterMap | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Option γ} {k : α}, m.WF → k ∈ Std.HashMap.Raw.filterMap f m → k ∈ m | null | true |
CategoryTheory.InducedWideCategory.congr_simp | Mathlib.CategoryTheory.Widesubcategory | ∀ {C : Type u₁} (D : Type u₂) [inst : CategoryTheory.Category.{v₁, u₂} D] (_F _F_1 : C → D),
_F = _F_1 →
∀ (_P _P_1 : CategoryTheory.MorphismProperty D) (e__P : _P = _P_1) [inst_1 : _P.IsMultiplicative],
CategoryTheory.InducedWideCategory D _F _P = CategoryTheory.InducedWideCategory D _F_1 _P_1 | null | true |
Std.HashMap.Raw.getElem?_insert | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k a : α} {v : β}, (m.insert k v)[a]? = if (k == a) = true then some v else m[a]? | null | true |
_private.Mathlib.Analysis.Real.Sqrt.0.Real.sq_le._simp_1_1 | Mathlib.Analysis.Real.Sqrt | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G},
(|a| ≤ b) = (-b ≤ a ∧ a ≤ b) | null | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.recv.match_1 | Std.Sync.Channel | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → ((val : α) → motive (some val)) → ((x : Option α) → motive x) → motive __do_lift | null | false |
_private.Mathlib.Data.DFinsupp.Multiset.0.DFinsupp.toMultiset_le_toMultiset._simp_1_1 | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, (s ≤ t) = (Multiset.toDFinsupp s ≤ Multiset.toDFinsupp t) | null | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit.eq_def | Lean.Elab.DeclNameGen | ∀ (e : Lean.Expr) (omitTopForall : Bool),
Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝ e omitTopForall = do
let __do_lift ← get
if Std.HashSet.contains (Lean.Elab.Command.NameGen.MkNameState.seen✝ __do_lift) e = true then pure ""
else do
let s ← Lean.Elab.Command.NameGen.mkBaseNameCore.visit'... | null | true |
_private.Mathlib.Data.DFinsupp.Lex.0.DFinsupp.lt_trichotomy_rec._proof_2 | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : LinearOrder ι]
[inst_2 : (i : ι) → LinearOrder (α i)] (f g : Π₀ (i : ι), α i), (f.neLocus g).min = ⊤ → toLex f = toLex g | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.checkUnsolvedDocMVars.match_1 | Lean.Elab.DocString | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((v : Lean.Expr) → motive (some v)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Set.Definable.image_comp_equiv | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {β : Type u_1}
{s : Set (β → M)}, A.Definable L s → ∀ (f : α ≃ β), A.Definable L ((fun g => g ∘ ⇑f) '' s) | null | true |
Std.ExtDTreeMap.Const.mem_toList_iff_get?_eq_some | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {v : β},
(k, v) ∈ Std.ExtDTreeMap.Const.toList t ↔ Std.ExtDTreeMap.Const.get? t k = some v | null | true |
Lean.Meta.SolveByElim.saturateSymm | Lean.Meta.Tactic.SolveByElim | Bool → List Lean.Expr → Lean.MetaM (List Lean.Expr) | If `symm` is `true`, then adds in symmetric versions of each hypothesis.
| true |
ConvexCone.mem_mk | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] {s : Set M} {x : M} {h₁ : ∀ ⦃c : R⦄, 0 < c → ∀ ⦃x : M⦄, x ∈ s → c • x ∈ s}
{h₂ : ∀ ⦃x : M⦄, x ∈ s → ∀ ⦃y : M⦄, y ∈ s → x + y ∈ s}, x ∈ { carrier := s, smul_mem' := h₁, add_mem' := h₂ } ↔ x ∈ ... | null | true |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.FunBinders.elabFunBinderViews | Lean.Elab.Binders | Array Lean.Elab.Term.BinderView →
ℕ → Lean.Elab.Term.FunBinders.State → Lean.Elab.TermElabM Lean.Elab.Term.FunBinders.State | null | true |
Nat.one_lt_succ_succ | Init.Data.Nat.Lemmas | ∀ (n : ℕ), 1 < n.succ.succ | null | true |
_private.Qq.Commands.0.Qq.mkLetFVarsFromValues | Qq.Commands | Array Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Build a let expression, similarly to `mkLetFVars`.
The array of `values` will be assigned to the current local context,
which is expected to consist of `cdecl`s.
| true |
Complex.isCauSeq_exp | Mathlib.Analysis.Complex.Exponential | ∀ (z : ℂ), IsCauSeq (fun x => ‖x‖) fun n => ∑ m ∈ Finset.range n, z ^ m / ↑m.factorial | null | true |
List.monotone_sum_take | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] (L : List M),
Monotone fun i => (List.take i L).sum | null | true |
AddMonoidAlgebra.smulZeroClass._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] {A : Type u_3} [inst_1 : SMulZeroClass A R] (a : A), a • 0 = 0 | null | false |
CategoryTheory.Bicategory.Prod.snd_map₂ | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C] {a b : B × C}
{f g : a ⟶ b} (a_1 : f ⟶ g), (CategoryTheory.Bicategory.Prod.snd B C).map₂ a_1 = a_1.2 | null | true |
ContinuousMap.Homotopy.ulift_apply | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) (i : ULift.{u, 0} ↑unitInterval) (x : ↑X),
H.uliftMap (i, x) = H (i.down, x) | null | true |
_private.Lean.Elab.Do.Switch.0.Lean.Elab.Term.expandTermTry._regBuiltin.Lean.Elab.Term.expandTermTry.declRange_3 | Lean.Elab.Do.Switch | IO Unit | null | false |
Finsupp.coe_mk | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] (f : α → M) (s : Finset α) (h : ∀ (a : α), a ∈ s ↔ f a ≠ 0),
⇑{ support := s, toFun := f, mem_support_toFun := h } = f | null | true |
UInt16.ofNatTruncate_toNat | Init.Data.UInt.Lemmas | ∀ (n : UInt16), UInt16.ofNatClamp n.toNat = n | null | true |
Int.getElem_toList_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ} (_h : i < (m<...n).toList.length), (m<...n).toList[i] = m + 1 + ↑i | null | true |
Rep.coinvariantsTensorIndInv._proof_2 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} [inst : CommRing k] {G H : Type u_1} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u_1, u_1, u_1} k G) (B : Rep.{u_1, u_1, u_1} k H),
SMulCommClass k k
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep.{u_1, u_1, u_1} k H)).obj (Rep.ind φ A)).obj B).ρ.Coinvariants | null | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.Basic.0.mdifferentiableWithinAt_congr_set'._simp_1_1 | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra.0.CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.ext.match_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u_5} {inst : CategoryTheory.Category.{u_3, u_5} C}
{F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat)}
{ι : Type u_1} {S : C} {X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ : F.DescentDataAsCoalgebra f}
(motive : D₁.Hom D₂ → ... | null | false |
AffineIndepOn.id_insert | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : Set P} {q : P},
AffineIndepOn k id s → q ∉ affineSpan k s → AffineIndepOn k id (insert q s) | null | true |
Std.DTreeMap.Internal.Impl.length_keys | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → t.keys.length = t.size | null | true |
_private.Aesop.RuleTac.Cases.0.Aesop.RuleTac.cases.go.match_10 | Aesop.RuleTac.Cases | (motive : Option (Array Lean.Meta.CasesSubgoal) → Sort u_1) →
(__x : Option (Array Lean.Meta.CasesSubgoal)) →
((goals : Array Lean.Meta.CasesSubgoal) → motive (some goals)) →
((x : Option (Array Lean.Meta.CasesSubgoal)) → motive x) → motive __x | null | false |
MeasureTheory.Measure.AbsolutelyContinuous.support_mono | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ ν : MeasureTheory.Measure X},
μ.AbsolutelyContinuous ν → μ.support ⊆ ν.support | null | true |
List.getLast._proof_1 | Init.Data.List.Basic | ∀ {α : Type u_1}, [] = [] | null | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.error.noConfusion | Mathlib.Tactic.TacticAnalysis.Declarations | {P : Sort u} →
{stx : Lean.TSyntax `tactic} →
{msg : Lean.MessageData} →
{stx' : Lean.TSyntax `tactic} →
{msg' : Lean.MessageData} →
Mathlib.TacticAnalysis.TerminalReplacementOutcome.error✝ stx msg =
Mathlib.TacticAnalysis.TerminalReplacementOutcome.error✝ stx' msg' →
... | null | false |
DirectSum.GSemiring.casesOn | Mathlib.Algebra.DirectSum.Ring | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : AddMonoid ι] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
{motive : DirectSum.GSemiring A → Sort u} →
(t : DirectSum.GSemiring A) →
([toGNonUnitalNonAssocSemiring : DirectSum.GNonUnitalNonAssocSemiring A] →
[toGOne :... | null | false |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_13 | Lean.Elab.Tactic.Simp | (motive : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult → Sort u_1) →
(x : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult) →
((ref : Lean.Syntax) → (arg : Lean.Elab.Tactic.ElabSimpArgResult) → motive (ref, arg)) → motive x | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_iff_forall_isSome_getEntry?.match_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : List ((a : α) × β a) → Prop) (x : List ((a : α) × β a)),
(∀ (_ : Unit), motive []) → (∀ (k : α) (v : β k) (l : List ((a : α) × β a)), motive (⟨k, v⟩ :: l)) → motive x | null | false |
Finset.piecewise | Mathlib.Data.Finset.Piecewise | {ι : Type u_1} →
{π : ι → Sort u_2} →
(s : Finset ι) → ((i : ι) → π i) → ((i : ι) → π i) → [(j : ι) → Decidable (j ∈ s)] → (i : ι) → π i | `s.piecewise f g` is the function equal to `f` on the finset `s`, and to `g` on its
complement. | true |
AbstractSimplicialComplex.mk | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | {ι : Type u_1} →
(toPreAbstractSimplicialComplex : PreAbstractSimplicialComplex ι) →
(∀ (v : ι), {v} ∈ toPreAbstractSimplicialComplex.faces) → AbstractSimplicialComplex ι | null | true |
PhragmenLindelof.eq_zero_on_quadrant_IV | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E},
DiffContOnCl ℂ f (Set.Ioi 0 ×ℂ Set.Iio 0) →
(∃ c < 2,
∃ B, f =O[Bornology.cobounded ℂ ⊓ Filter.principal (Set.Ioi 0 ×ℂ Set.Iio 0)] fun z => Real.exp (B * ‖z‖ ^ c)) →
(∀ (x : ℝ), 0 ≤ x → f ↑x = 0) → (∀ x ≤ 0, f (↑x... | **Phragmen-Lindelöf principle** in the fourth quadrant. Let `f : ℂ → E` be a function such that
* `f` is differentiable in the open fourth quadrant and is continuous on its closure;
* `‖f z‖` is bounded from above by `A * exp(B * ‖z‖ ^ c)` on the open fourth quadrant
for some `A`, `B`, and `c < 2`;
* `f` is equal to... | true |
IsTopologicalRing.toIsSemitopologicalRing | Mathlib.Topology.Algebra.Ring.Basic | ∀ (R : Type u_2) [inst : TopologicalSpace R] [inst_1 : NonUnitalNonAssocRing R] [IsTopologicalRing R],
IsSemitopologicalRing R | null | true |
_private.Mathlib.Topology.Order.LeftRightLim.0.Monotone.leftLim_le._simp_1_4 | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Monotone.withTop_map | Mathlib.Order.WithBot | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Monotone f → Monotone (WithTop.map f) | **Alias** of the reverse direction of `WithTop.monotone_map_iff`. | true |
npow_mul_comm | Mathlib.Algebra.Group.NatPowAssoc | ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [NatPowAssoc M] (m n : ℕ) (x : M),
x ^ m * x ^ n = x ^ n * x ^ m | null | true |
MonCat.Colimits.quot_one | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] (F : CategoryTheory.Functor J MonCat),
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) MonCat.Colimits.Prequotient.one = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.