name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DirectSum.IsInternal.subordinateOrthonormalBasis_subordinate | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : FiniteDimensional 𝕜 E] {n : ℕ}
(hn : Module.finrank 𝕜 E = n) [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
(a : Fi... | The basis constructed in `DirectSum.IsInternal.subordinateOrthonormalBasis` is subordinate to
the `OrthogonalFamily` in question. | true |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_nontrivial_inv._simp_1_10 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Lean.JsonRpc.instCoeOutResponseErrorMessageOfToJson | Lean.Data.JsonRpc | {α : Type u_1} → [Lean.ToJson α] → CoeOut (Lean.JsonRpc.ResponseError α) Lean.JsonRpc.Message | null | true |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.seq_eq.match_1_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} {β : Type u_1} (motive : (x : ℕ) → (Fin x → α → β) → (Fin x → α) → Prop) (x : ℕ) (x_1 : Fin x → α → β)
(x_2 : Fin x → α),
(∀ (x : Fin 0 → α → β) (x_3 : Fin 0 → α), motive 0 x x_3) →
(∀ (n : ℕ) (f : Fin (n + 1) → α → β) (v : Fin (n + 1) → α), motive n.succ f v) → motive x x_1 x_2 | null | false |
_private.Mathlib.RingTheory.Algebraic.StronglyTranscendental.0.isStronglyTranscendental_iff_of_field._simp_1_5 | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ (α : Type u_3) [Nontrivial α], Subsingleton α = False | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt64.shiftLeft_or._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryGT._f | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(x : Std.DTreeMap.Internal.Impl α fun x => β) →
Std.DTreeMap.Internal.Impl.below (motive := fun x =>
x.Ordered → (∃ a ∈ x, compare a k = Ordering.gt) → α × β) x →
x.Ordered... | null | false |
_private.Init.Data.List.Nat.Range.0.List.sum_range'._simp_1_1 | Init.Data.List.Nat.Range | ∀ (n m k : ℕ), n + (m + k) = n + m + k | null | false |
Std.Rxc.Iterator.rec | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} →
{motive : Std.Rxc.Iterator α → Sort u_1} →
((next : Option α) → (upperBound : α) → motive { next := next, upperBound := upperBound }) →
(t : Std.Rxc.Iterator α) → motive t | null | false |
TopRep.hom_id | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u} {G : Type v} [inst : TopologicalSpace k] [inst_1 : Ring k] [inst_2 : Monoid G] (A : TopRep k G),
TopRep.Hom.hom (CategoryTheory.CategoryStruct.id A) = ContIntertwiningMap.id | null | true |
NonUnitalAlgHom.snd | Mathlib.Algebra.Algebra.NonUnitalHom | (R : Type u) →
[inst : Monoid R] →
(A : Type v) →
(B : Type w) →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : NonUnitalNonAssocSemiring B] → [inst_4 : DistribMulAction R B] → A × B →ₙₐ[R] B | The second projection of a product is a non-unital algebra homomorphism. | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Assignment.0.Std.Tactic.BVDecide.LRAT.Internal.Assignment.extendOfClauseWithout_spec._simp_1_24 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
CategoryTheory.Localization.Monoidal.instLiftingLocalizedMonoidalToMonoidalCategoryCompTensorLeftObjFunctorTensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {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] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 ... | null | true |
Lean.Elab.Tactic.evalTacticSeqBracketed | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | null | true |
Module.Relations.Solution.postcomp_id | 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.postcomp LinearMap.id = solution | null | true |
Quaternion.normSq_ne_zero | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
Quaternion.normSq a ≠ 0 ↔ a ≠ 0 | null | true |
MonoidAlgebra.single_commute_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {r₁ r₂ : R} {m₁ m₂ : M} [inst_1 : Mul M],
Commute m₁ m₂ → Commute r₁ r₂ → Commute (MonoidAlgebra.single m₁ r₁) (MonoidAlgebra.single m₂ r₂) | null | true |
_private.Init.Data.Array.Lemmas.0.Array.eq_push_pop_back!_of_size_ne_zero._simp_1_1 | Init.Data.Array.Lemmas | ∀ {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [inst : GetElem? cont idx elem dom]
[LawfulGetElem cont idx elem dom] [inst_2 : Inhabited elem] (c : cont) (i : idx) (h : dom c i), c[i] = c[i]! | null | false |
Polynomial.monic_one | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic 1 | null | true |
Std.ExtDHashMap.getKeyD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k fallback : α}, (m₁ ∪ m₂).getKeyD k fallback = m₂.getKeyD k (m₁.getKeyD k fallback) | null | true |
FirstOrder.Language.Theory.CompleteType.formula_mem_typeOf | Mathlib.ModelTheory.Types | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {M : Type w'} [inst : L.Structure M] [inst_1 : Nonempty M]
[inst_2 : M ⊨ T] {v : α → M} {φ : L.Formula α}, FirstOrder.Language.Formula.equivSentence φ ∈ T.typeOf v ↔ φ.Realize v | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith.disjoint_iff_ne._simp_1_4 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
SimpleGraph.Subgraph.support_mono | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph}, H ≤ H' → H.support ⊆ H'.support | null | true |
lebesgue_number_lemma_of_emetric_nhdsWithin | Mathlib.Topology.EMetricSpace.Basic | ∀ {γ : Type w} [inst : EMetricSpace γ] {s : Set γ} {c : γ → Set γ},
IsCompact s → (∀ x ∈ s, c x ∈ nhdsWithin x s) → ∃ δ > 0, ∀ x ∈ s, ∃ y, Metric.eball x δ ∩ s ⊆ c y | null | true |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.applyResponse.match_1 | Std.Http.Server.Connection | (motive : Option Std.Http.Body.Length → Sort u_1) →
(size : Option Std.Http.Body.Length) →
((knownSize : Std.Http.Body.Length) → motive (some knownSize)) →
((x : Option Std.Http.Body.Length) → motive x) → motive size | null | false |
ZLattice.comap_equiv._proof_4 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_2) [inst : NormedField K] {E : Type u_3} {F : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace K F] (L : Submodule ℤ E)
(e : F ≃ₗ[K] E), ∀ x ∈ L, (↑ℤ ↑e.symm) x ∈ ZLattice.comap K L ↑e | null | false |
map_inj_right_of_nonempty._simp_1 | Init.Control.Lawful.Lemmas | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} [inst : Functor m] [LawfulFunctor m] [Nonempty α] {f : α → β},
(∀ {x y : α}, f x = f y → x = y) → ∀ {x y : m α}, (f <$> x = f <$> y) = (x = y) | null | false |
Lean.Lsp.WorkspaceEdit.ofTextEdit | Lean.Data.Lsp.Basic | Lean.Lsp.VersionedTextDocumentIdentifier → Lean.Lsp.TextEdit → Lean.Lsp.WorkspaceEdit | null | true |
StateM | Init.Control.State | Type u → Type u → Type u | A tuple-based state monad.
Actions in `StateM σ` are functions that take an initial state and return a value paired with a
final state.
| true |
ContinuousLinearEquiv.smulLeft._proof_3 | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {M₁ : Type u_1} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {G : Type u_2} [inst_2 : Group G]
[inst_3 : DistribMulAction G M₁] [ContinuousConstSMul G M₁], Continuous fun x => 1 • x | null | false |
_private.Mathlib.Data.Nat.Hyperoperation.0.hyperoperation.match_1.eq_4 | Mathlib.Data.Nat.Hyperoperation | ∀ (motive : ℕ → ℕ → ℕ → Sort u_1) (n x : ℕ) (h_1 : (x k : ℕ) → motive 0 x k) (h_2 : (m : ℕ) → motive 1 m 0)
(h_3 : (x : ℕ) → motive 2 x 0) (h_4 : (n x : ℕ) → motive n.succ.succ.succ x 0)
(h_5 : (n m k : ℕ) → motive n.succ m k.succ),
(match n.succ.succ.succ, x, 0 with
| 0, x, k => h_1 x k
| 1, m, 0 => h_2 ... | null | true |
AlgHom.fst_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), (AlgHom.fst R B C).comp (f.prod g) = f | null | true |
IsFractionRing.semilinearEquivOfRingEquiv._proof_1 | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B], RingHomClass (A ≃+* B) A B | null | false |
IsBaseChange.linearMap | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_1) (S : Type v₃) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsBaseChange S (Algebra.linearMap R S) | null | true |
differentiableWithinAt_abs_neg | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ (s : Set ℝ) {x : ℝ}, x < 0 → DifferentiableWithinAt ℝ (fun x => |x|) s x | null | true |
CategoryTheory.SpectralSequence.Hom.mk.noConfusion | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{E E' : CategoryTheory.SpectralSequence C c r₀} →
{P : Sort u} →
{hom :
... | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Ring.0.CategoryTheory.mul_add_iff._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.not_isPreconnected_compl_pair._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
VectorField.mpullbackWithin_smul | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : 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 |
_private.Mathlib.Analysis.Complex.AbsMax.0.Complex.norm_le_of_forall_mem_frontier_norm_le._simp_1_1 | Mathlib.Analysis.Complex.AbsMax | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Setoid.ker_def | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x y : α}, (Setoid.ker f) x y ↔ f x = f y | null | true |
MeasureTheory.Measure.instSub | Mathlib.MeasureTheory.Measure.Sub | {α : Type u_1} → [inst : MeasurableSpace α] → Sub (MeasureTheory.Measure α) | The measure `μ - ν` is defined to be the least measure `τ` such that `μ ≤ τ + ν`.
It is equivalent to `(μ - ν) ⊔ 0` if `μ` and `ν` were signed measures.
Compare with `ENNReal.instSub`.
Specifically, note that if you have `α = {1,2}`, and `μ {1} = 2`, `μ {2} = 0`, and
`ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`.... | true |
_private.Lean.Meta.Tactic.Rfl.0.Lean.Meta.Rfl.initFn._sparseCasesOn_3._@.Lean.Meta.Tactic.Rfl.914023288._hygCtx._hyg.2 | Lean.Meta.Tactic.Rfl | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.Repr.0.Decidable.repr.match_1 | Init.Data.Repr | {p : Prop} →
(motive : Decidable p → ℕ → Sort u_1) →
(x : Decidable p) →
(x_1 : ℕ) →
((reflects_decide : p) → (prec : ℕ) → motive { decide := true, reflects_decide := reflects_decide } prec) →
((reflects_decide : ¬p) → (prec : ℕ) → motive { decide := false, reflects_decide := reflects_deci... | null | false |
IsStrictWeakOrder.incomp_trans | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {lt : α → α → Prop} [self : IsStrictWeakOrder α lt] (a b c : α),
¬lt a b ∧ ¬lt b a → ¬lt b c ∧ ¬lt c b → ¬lt a c ∧ ¬lt c a | null | true |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.whiskerLeftIso.congr_simp | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ : CategoryTheory.Arrow C) {W : C}
[inst_3 :
CategoryTheory.Limits.PreservesColimit
(CategoryTheory.Limits.span (CategoryTheory.MonoidalCategoryStruct.... | null | true |
Ideal.torsionOf.eq_1 | Mathlib.Algebra.Module.Torsion.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
Ideal.torsionOf R M x = (LinearMap.toSpanSingleton R M x).ker | null | true |
_private.Lean.Elab.Quotation.Precheck.0.Lean.Elab.Term.Quotation.precheckHygieneInfo.match_1 | Lean.Elab.Quotation.Precheck | (motive : Lean.Syntax → Sort u_1) → (x : Lean.Syntax) → ((x : Lean.Syntax) → motive x) → motive x | null | false |
SimpleGraph.instDecidableRelAdjDeleteEdgesOfDecidablePredSym2MemSetOfDecidableEq | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} →
{G : SimpleGraph V} →
{s : Set (Sym2 V)} →
[DecidableRel G.Adj] → [DecidablePred fun x => x ∈ s] → [DecidableEq V] → DecidableRel (G.deleteEdges s).Adj | null | true |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute.match_1_20 | Mathlib.RingTheory.Nilpotent.Exp | (motive : (_ : ℕ) × ℕ → Sort u_1) → (x : (_ : ℕ) × ℕ) → ((i j : ℕ) → motive ⟨i, j⟩) → motive x | null | false |
Stream'.Seq.map_append | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s t : Stream'.Seq α),
Stream'.Seq.map f (s.append t) = (Stream'.Seq.map f s).append (Stream'.Seq.map f t) | null | true |
Real.tendsto_mul_log_one_add_of_tendsto | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {g : ℝ → ℝ} {t : ℝ},
Filter.Tendsto (fun x => x * g x) Filter.atTop (nhds t) →
Filter.Tendsto (fun x => x * Real.log (1 + g x)) Filter.atTop (nhds t) | The limit of `x * log (1 + g x)` as `(x : ℝ) → ∞` is `t`,
where `t : ℝ` is the limit of `x * g x`. | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting_0_CategoryTheory_Limits_termX₁_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.Macro | null | false |
instNegNonemptyInterval.eq_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedAddMonoid α],
instNegNonemptyInterval = { neg := fun s => { fst := -s.toProd.2, snd := -s.toProd.1, fst_le_snd := ⋯ } } | null | true |
PadicInt.withValIntegersRingEquiv._proof_7 | Mathlib.NumberTheory.Padics.WithVal | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (x : (Rat.padicValuation p).Completion),
Valued.v x ≤ 1 ↔ ‖Padic.withValUniformEquiv x‖ ≤ 1 | null | false |
Multiset.prod_lt_prod' | Mathlib.Algebra.Order.BigOperators.Group.Multiset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α] [IsOrderedCancelMonoid α]
[MulLeftStrictMono α] {s : Multiset ι} {f g : ι → α},
(∀ i ∈ s, f i ≤ g i) → (∃ i ∈ s, f i < g i) → (Multiset.map f s).prod < (Multiset.map g s).prod | **Alias** of `Multiset.prod_lt_prod`. | true |
Units.val_neg._simp_1 | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] (u : αˣ), -↑u = ↑(-u) | null | false |
Set.domRestrict_def | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {π : α → Type u_5} (s : Set α), s.domRestrict = fun f x => f ↑x | null | true |
ultrafilterBasis | Mathlib.Topology.Compactification.StoneCech | (α : Type u) → Set (Set (Ultrafilter α)) | Basis for the topology on `Ultrafilter α`. | true |
Lean.JsonRpc.Message.ctorElimType | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.Message → Sort u} → ℕ → Sort (max 1 u) | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.rayleighQuotient_le_of_mem_resolventSet | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E) (t : ℝ),
0 < t →
(algebraMap ℝ 𝕜) t ∈ resolventSet 𝕜 T → ∃ c > 0, ∀ (x : E), T.rayleighQuotient x ≤ (t ^ 2 + ‖T‖ ^ 2) / (2 * t) - c | null | true |
HasCountableSeparatingOn.range_Iio | Mathlib.Topology.Order.CountableSeparating | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : LinearOrder X] [OrderTopology X] [SecondCountableTopology X]
{s : Set X}, HasCountableSeparatingOn X (fun x => x ∈ Set.range Set.Iio) s | null | true |
Finset.fold_hom | Mathlib.Data.Finset.Fold | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op]
{f : α → β} {b : β} {s : Finset α} {op' : γ → γ → γ} [inst : Std.Commutative op'] [inst_1 : Std.Associative op']
{m : β → γ},
(∀ (x y : β), m (op x y) = op' (m x) (m y)) → Finset.fold op' (m b) (fun... | null | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.mk_mem_graph_iff._simp_1_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.Triangulated.0.CochainComplex.MappingConeCompHomotopyEquiv.hom._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ (p : ℤ), p + 2 + -1 = p + 1 | null | false |
_private.Lean.DocString.Markdown.0.Lean.Doc.foldEntries.match_1 | Lean.DocString.Markdown | (motive : Lean.Name × Lean.Name → Sort u_1) →
(x : Lean.Name × Lean.Name) → ((tag w : Lean.Name) → motive (tag, w)) → motive x | null | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_133 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (w_1 n : ℕ)
(expr : Std.Tactic.BVDecide.BVExpr w_1) (h : w = w_1 * n),
¬llhs.shiftLeft lrhs = Std.Tactic.BVDecide.BVExpr.replicate n expr h | null | false |
MeasureTheory.isMulRightInvariant_map_mul_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Semigroup G] [MeasurableMul G] {μ : MeasureTheory.Measure G}
[μ.IsMulRightInvariant] (g : G), (MeasureTheory.Measure.map (fun x => g * x) μ).IsMulRightInvariant | The image of a right invariant measure under left multiplication is right invariant. | true |
FirstOrder.Language.Term.lt | Mathlib.ModelTheory.Order | {L : FirstOrder.Language} →
{α : Type w} → {n : ℕ} → [L.IsOrdered] → L.Term (α ⊕ Fin n) → L.Term (α ⊕ Fin n) → L.BoundedFormula α n | Joins two terms `t₁, t₂` in a formula representing `t₁ < t₂`. | true |
Lean.NameMap.insert | Lean.Data.NameMap.Basic | {α : Type} → Lean.NameMap α → Lean.Name → α → Std.TreeMap Lean.Name α Lean.Name.quickCmp | null | true |
Polynomial.degree_smul_of_smul_regular | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : SMulZeroClass S R] {k : S} (p : Polynomial R),
IsSMulRegular R k → (k • p).degree = p.degree | null | true |
Bornology.relativelyCompact | Mathlib.Topology.Separation.Basic | (X : Type u_1) → [inst : TopologicalSpace X] → [R0Space X] → Bornology X | In an R₀ space, relatively compact sets form a bornology.
Its cobounded filter is `Filter.coclosedCompact`.
See also `Bornology.inCompact` the bornology of sets contained in a compact set. | true |
MonCat.forget_reflects_isos | Mathlib.Algebra.Category.MonCat.Basic | (CategoryTheory.forget MonCat).ReflectsIsomorphisms | null | true |
Lean.Elab.Command.ElabHeaderResult.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{t t' : Lean.Elab.Command.ElabHeaderResult} → t = t' → Lean.Elab.Command.ElabHeaderResult.noConfusionType P t t' | null | false |
ValuationSubring.ofPrime_localization | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (P : Ideal ↥A) [inst_1 : P.IsPrime],
IsLocalization.AtPrime (↥(A.ofPrime P)) P | null | true |
MeasureTheory.HasFundamentalDomain.ExistsIsFundamentalDomain | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_6} {α : Type u_7} {inst : One G} {inst_1 : SMul G α} {inst_2 : MeasurableSpace α}
{ν : autoParam (MeasureTheory.Measure α) MeasureTheory.HasFundamentalDomain._auto_1}
[self : MeasureTheory.HasFundamentalDomain G α ν], ∃ s, MeasureTheory.IsFundamentalDomain G s ν | null | true |
SemilatSupCat.isOrderBot | Mathlib.Order.Category.Semilat | (self : SemilatSupCat) → OrderBot self.X | null | true |
Filter.Germ.instPow.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [inst : Pow G M],
Filter.Germ.instPow = { pow := fun f n => Filter.Germ.map (fun x => x ^ n) f } | null | true |
IsIntegrallyClosed.of_isIntegrallyClosed_of_isIntegrallyClosedIn | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDomain S]
[FaithfulSMul R S] [IsIntegrallyClosed S] [IsIntegrallyClosedIn R S], IsIntegrallyClosed R | null | true |
CategoryTheory.ShortComplex.mapHomologyIso'._proof_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (S : CategoryTheory.ShortComplex C)
(F : CategoryTheory.Functor C D) [inst_4 : F.Pre... | null | false |
DFinsupp.update | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{β : ι → Type v} →
[inst : (i : ι) → Zero (β i)] → [DecidableEq ι] → (Π₀ (i : ι), β i) → (i : ι) → β i → Π₀ (i : ι), β i | Replace the value of a `Π₀ i, β i` at a given point `i : ι` by a given value `b : β i`.
If `b = 0`, this amounts to removing `i` from the support.
Otherwise, `i` is added to it.
This is the (dependent) finitely-supported version of `Function.update`. | true |
SeparationQuotient.instUniformSpace._proof_2 | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} [inst : UniformSpace α] (y : SeparationQuotient α),
nhds y = Filter.comap (Prod.mk y) (Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity α)) | null | false |
CategoryTheory.Adjunction.Triple.leftToRight.congr_simp | Mathlib.CategoryTheory.Adjunction.Triple | ∀ {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] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t t_1 : CategoryTheory.Adjunction.Triple F G H),
t = t_1 → ∀ [inst_2 : F.Full] [inst_3 :... | null | true |
Std.DTreeMap.Raw.instDecidableEquiv | Std.Data.DTreeMap.Raw.DecidableEquiv | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] →
[Std.LawfulEqCmp cmp] →
[inst : (k : α) → BEq (β k)] →
[∀ (k : α), LawfulBEq (β k)] → {t₁ t₂ : Std.DTreeMap.Raw α β cmp} → t₁.WF → t₂.WF → Decidable (t₁.Equiv t₂) | null | true |
Filter.ZeroAtFilter.neg | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] [inst_1 : SubtractionMonoid β] [ContinuousNeg β]
{l : Filter α} {f : α → β}, l.ZeroAtFilter f → l.ZeroAtFilter (-f) | null | true |
_private.Mathlib.Geometry.Euclidean.Volume.Basic.0.Affine.Simplex.evalVolume.match_1 | Mathlib.Geometry.Euclidean.Volume.Basic | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
Option Q(PartialOrder «$α») →
(e : Q(«$α»)) →
(val : Q(PartialOrder «$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x e (some val)) →
Lean.MetaM (Mathlib.Me... | null | false |
WithZero.lift'._proof_4 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulZeroOneClass β],
Function.LeftInverse (fun F => (↑F).comp WithZero.coeMonoidHom) fun f =>
{ toFun := fun n => WithZero.recZeroCoe 0 (⇑f) n, map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } | null | false |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S.cons | Mathlib.Tactic.DeriveEncodable | Mathlib.Deriving.Encodable.S✝ → Mathlib.Deriving.Encodable.S✝ → Mathlib.Deriving.Encodable.S✝ | null | true |
Std.Internal.UV.System.UnameInfo.mk.injEq | Std.Internal.UV.System | ∀ (sysname release version machine sysname_1 release_1 version_1 machine_1 : String),
({ sysname := sysname, release := release, version := version, machine := machine } =
{ sysname := sysname_1, release := release_1, version := version_1, machine := machine_1 }) =
(sysname = sysname_1 ∧ release = release_1... | null | true |
Lean.Order.instCCPOIO._proof_1 | Init.Internal.Order.Basic | ∀ {α : Type} {x : EIO IO.Error α}, Lean.Order.instCCPOEIOOfNonempty._aux_1 x x | null | false |
ContinuousLinearMap.mul._proof_1 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_2) [inst : NontriviallyNormedField 𝕜] (R : Type u_1) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R] [inst_3 : IsScalarTower 𝕜 R R] [inst_4 : SMulCommClass 𝕜 R R] (x y : R),
‖((LinearMap.mul 𝕜 R) x) y‖ ≤ 1 * ‖x‖ * ‖y‖ | null | false |
ZLattice.covolume.tendsto_card_le_div' | Mathlib.Algebra.Module.ZLattice.Covolume | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (L : Submodule ℤ E) [inst_5 : DiscreteTopology ↥L]
[IsZLattice ℝ L] [Nontrivial E] {X : Set E} {F : E → ℝ},
(∀ ⦃x : E⦄ ⦃r : ℝ⦄, x ∈ X → 0 < r → r • ... | A version of `ZLattice.covolume.tendsto_card_le_div` for the `InnerProductSpace` case;
see the `Naming convention` section in the introduction. | true |
Std.Broadcast.instHashableError | Std.Sync.Broadcast | Hashable Std.Broadcast.Error | null | true |
_private.Mathlib.Basic.ENNReal.Inv.0.ENNReal.inv_lt_top._simp_1_2 | Mathlib.Basic.ENNReal.Inv | ∀ {a : ENNReal}, (a⁻¹ ≠ ⊤) = (a ≠ 0) | null | false |
GeneralizingMap.stableUnderGeneralization_range | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
GeneralizingMap f → StableUnderGeneralization (Set.range f) | null | true |
instCommRingPointedContMDiffMap._proof_19 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ (𝕜 : 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] (n : WithTop ℕ∞) (x : M)
(a : Pointed... | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_19 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(0 + size ≤ 1 ∨ 0 ≤ 3 * size ∧ size ≤ 3 * 0) ∧ ls = 0 + 1 + size →
(3 * (0 + 1 + (l.s... | null | false |
Std.Internal.UV.TCP.Socket.new | Std.Internal.UV.TCP | IO Std.Internal.UV.TCP.Socket | Creates a new TCP socket.
| true |
Lean.Expr.fvar.sizeOf_spec | Lean.Expr | ∀ (fvarId : Lean.FVarId), sizeOf (Lean.Expr.fvar fvarId) = 1 + sizeOf fvarId | null | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.noMVars.elim | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝) →
Lean.Meta.PreprocessKind.ctorIdx✝ t = 0 → motive Lean.Meta.PreprocessKind.noMVars✝ → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.