name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Internal.List.maxKey?_le_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
{k km : α} {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ (hc : Std.Internal.List.containsKey k l = true),
(Std.Internal.List.maxKey? l).get ⋯ = km → (compare k km).isL... | null | true |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Meta.Grind.Params.containsEMatch | Lean.Elab.Tactic.Grind.Param | Lean.Meta.Grind.Params → Lean.Name → Bool | null | true |
AlgebraicGeometry.isAffineHom_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.Affine | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsAffine X] [AlgebraicGeometry.IsAffine Y],
AlgebraicGeometry.IsAffineHom f | null | true |
FirstOrder.Language.IsExtensionPair.definedAtLeft | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] → [inst_1 : L.Structure N] → L.IsExtensionPair M N → M → Order.Cofinal (L.FGEquiv M N) | The cofinal set of finite equivalences with a given element in their domain. | true |
DirectSum.instCommRingOfNat._proof_7 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommRing A] (g h : A 0),
(DirectSum.of A 0) (g - h) = (DirectSum.of A 0) g - (DirectSum.of A 0) h | null | false |
Equiv.transPartialEquiv_source | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ),
(e.transPartialEquiv f').source = ⇑e ⁻¹' f'.source | null | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} (motive : Turing.TM0to1.Λ' Γ Λ → Sort u_3) (d : Turing.Dir) (q : Λ)
(h_1 : (q : Λ) → motive (Turing.TM0to1.Λ'.normal q))
(h_2 : (d : Turing.Dir) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.move d) q))
(h_3 : (a : Γ) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey_modify._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Subalgebra.ofRestrictScalars._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Tower | ∀ {S : Type u_2} {A : Type u_1} [inst : CommSemiring S] [inst_1 : Semiring A] [inst_2 : Algebra S A],
AddSubmonoidClass (Subalgebra S A) A | null | false |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} {bv : BitVec w} {w_1 : ℕ} {bv_1 : BitVec w_1},
{ w := w, bv := bv } = { w := w_1, bv := bv_1 } → w = w_1 ∧ bv ≍ bv_1 | null | true |
SimpleGraph.cliqueFree_of_card_lt | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ} [inst : Fintype α], Fintype.card α < n → G.CliqueFree n | See `SimpleGraph.cliqueFree_of_chromaticNumber_lt` for a tighter bound. | true |
MvPowerSeries.subst_X | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S},
MvPowerSeries.HasSubst a → ∀ (s : σ), MvPowerSeries.subst a (MvPowerSeries.X s) = a s | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Definability.0.FirstOrder.Language.presburger.mul_not_definable._proof_1_6 | Mathlib.ModelTheory.Arithmetic.Presburger.Definability | ∀ (k p : ℕ), p > 0 → ∀ (x : ℕ), x * x = max k p * max k p + p → x * x ≤ max k p * max k p → False | null | false |
PresheafOfModules.ModuleColimit.homEquiv._proof_7 | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
[inst_2 : CategoryTheory.IsCofiltered C] [inst_3 : CategoryTheory.InitiallySmall C]
{R : CategoryTheory.Functor Cᵒᵖ RingCat} {cR : CategoryTheory.Limits.Cocone R}
(hcR : CategoryTheory.Limits.Is... | null | false |
have_body_congr_dep' | Init.SimpLemmas | ∀ {α : Sort u} {β : α → Sort v} (a : α) {f f' : (x : α) → β x}, (∀ (x : α), f x = f' x) → f a = f' a | null | true |
commGrpTypeEquivalenceCommGrp._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.Types.CommGrp_ | ∀ (X : CategoryTheory.CommGrp (Type u_1)),
CategoryTheory.CategoryStruct.comp
(CommGrpTypeEquivalenceCommGrp.functor.map
((CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.CommGrp (Type u_1)))).hom.app X))
((CategoryTheory.NatIso.ofComponents
(fun A =>
... | null | false |
CompactlyGeneratedSpace.isClosed | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactlyGeneratedSpace X] {s : Set X},
(∀ ⦃K : Set X⦄, IsCompact K → IsClosed (s ∩ K)) → IsClosed s | In a compactly generated space `X`, a set `s` is closed when `s ∩ K` is
closed for every compact set `K`. | true |
Std.HashMap.mem_keys | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] {k : α},
k ∈ m.keys ↔ k ∈ m | null | true |
isInducing_stoneCechUnit | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X] [CompletelyRegularSpace X], Topology.IsInducing stoneCechUnit | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.IsIndex.δ._simp_7 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_13 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) | null | false |
Lean.Doc.State._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.State | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.two_nsmul_eq_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {ψ θ : Real.Angle}, (2 • ψ = 2 • θ) = (ψ = θ ∨ ψ = θ + ↑Real.pi) | null | false |
Part.Fix.approx._unsafe_rec | Mathlib.Control.Fix | {α : Type u_1} → {β : α → Type u_2} → (((a : α) → Part (β a)) → (a : α) → Part (β a)) → Stream' ((a : α) → Part (β a)) | null | false |
CategoryTheory.GradedObject.mapTrifunctorMap_obj | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | true |
FiniteDimensional.of_locallyCompactSpace | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {E : Type u_5} [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [T2Space E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E]
[WeaklyLocallyCompactSpace E], FiniteDimensional 𝕜 E | **Riesz's theorem**: a locally compact topological vector space is finite-dimensional. | true |
ProjectiveSpectrum.ctorIdx | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
{inst : CommRing A} →
{inst_1 : SetLike σ A} →
{inst_2 : AddSubmonoidClass σ A} → {𝒜 : ℕ → σ} → {inst_3 : GradedRing 𝒜} → ProjectiveSpectrum 𝒜 → ℕ | null | false |
rTensor.inverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | true |
TopologicalSpace.NonemptyCompacts.instPartialOrder | Mathlib.Topology.Sets.Compacts | {α : Type u_1} → [inst : TopologicalSpace α] → PartialOrder (TopologicalSpace.NonemptyCompacts α) | null | true |
Lean.Expr.fvar.inj | Lean.Expr | ∀ {fvarId fvarId_1 : Lean.FVarId}, Lean.Expr.fvar fvarId = Lean.Expr.fvar fvarId_1 → fvarId = fvarId_1 | null | true |
OpenNormalAddSubgroup.toFiniteIndexNormalAddSubgroup._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [CompactSpace G] [ContinuousAdd G]
(H : OpenNormalAddSubgroup G), (↑H.toOpenAddSubgroup).FiniteIndex | null | false |
CategoryTheory.WithTerminal.comp.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithTerminal C) (_X : C),
CategoryTheory.WithTerminal.comp = fun _f _g => PUnit.unit | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateDelImp.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Code pu → Sort u_1) →
(c : Lean.Compiler.LCNF.Code pu) →
((fvarId : Lean.FVarId) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.Code.del fvarId k h)) →
... | null | false |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.tensorCotangentInv._proof_2 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
{P : Algebra.Generators R S ι} {σ : Type u_4} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
SMulCommClass (Algebra.Generators.Presentation... | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkGrindEqnParams | Lean.Elab.Tactic.Try | Array Lean.Name → Lean.MetaM (Array (Lean.TSyntax `Lean.Parser.Tactic.grindParam)) | Given a set of declaration names, returns `grind` parameters of the form `= <declName>` | true |
Subtype.restrict_def | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} (f : α → β) (p : α → Prop), Subtype.restrict p f = f ∘ fun a => ↑a | null | true |
String.Pos.ofToSlice_comp_toSlice | Init.Data.String.Basic | ∀ {s : String}, String.Pos.ofToSlice ∘ String.Pos.toSlice = id | null | true |
Prod.mk_dvd_mk._simp_1 | Mathlib.Algebra.Divisibility.Prod | ∀ {G₁ : Type u_2} {G₂ : Type u_3} [inst : Semigroup G₁] [inst_1 : Semigroup G₂] {x₁ y₁ : G₁} {x₂ y₂ : G₂},
((x₁, x₂) ∣ (y₁, y₂)) = (x₁ ∣ y₁ ∧ x₂ ∣ y₂) | null | false |
Coalgebra.Quotient.instQuotientSubmodule._proof_6 | Mathlib.RingTheory.Coalgebra.Quotient | ∀ {R : Type u_1} {C : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup C] [inst_2 : Module R C] (I : Submodule R C),
SMulCommClass R R (TensorProduct R (C ⧸ I) R) | null | false |
RelEmbedding.mul_apply | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (e₁ e₂ : r ↪r r) (x : α), (e₁ * e₂) x = e₁ (e₂ x) | null | true |
_private.Mathlib.Topology.Separation.Regular.0.regularSpace_TFAE.match_1_7 | Mathlib.Topology.Separation.Regular | ∀ (X : Type u_1) [inst : TopologicalSpace X]
(motive : (∀ (x : X), (nhds x).lift' closure = nhds x) → (x : X) → (x_1 : Set X) → x_1 ∈ nhds x → Prop)
(x : ∀ (x : X), (nhds x).lift' closure = nhds x) (x_1 : X) (x_2 : Set X) (x_3 : x_2 ∈ nhds x_1),
(∀ (H : ∀ (x : X), (nhds x).lift' closure = nhds x) (a : X) (s : Set... | null | false |
Int.natCast_le_zero._simp_1 | Init.Data.Int.LemmasAux | ∀ {n : ℕ}, (↑n ≤ 0) = (n = 0) | null | false |
Finset.one_le_prod' | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : CommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι} [MulLeftMono N],
(∀ i ∈ s, 1 ≤ f i) → 1 ≤ ∏ i ∈ s, f i | **Alias** of `Finset.one_le_prod`. | true |
Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_left | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPartialOrder R]
[Lean.Grind.OrderedRing R] [Std.LawfulOrderLT R] {a b c : R}, a ≤ b → 0 ≤ c → c * a ≤ c * b | null | true |
CategoryTheory.ComposableArrows.Precomp.map._proof_7 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (i : ℕ) (hi : i + 1 < n + 1 + 1) (j : ℕ) (hj : j + 1 < n + 1 + 1), ⟨i + 1, hi⟩ ≤ ⟨j + 1, hj⟩ → i ≤ j | null | false |
_private.Mathlib.Topology.Homotopy.Product.0.Path.Homotopic.«_aux_Mathlib_Topology_Homotopy_Product___macroRules__private_Mathlib_Topology_Homotopy_Product_0_Path_Homotopic_term_⬝__1» | Mathlib.Topology.Homotopy.Product | Lean.Macro | null | false |
contDiffOn_of_analyticOn_of_fderivWithin | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞}, AnalyticOn 𝕜 f s → ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s → C... | null | true |
RootPairing.Hom.mk.injEq | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | true |
CochainComplex.HomComplex.coboundaries.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ),
CochainComplex.HomComplex.coboundaries K L n =
{ carrier := {α | ∃ m, ∃ (_ : m + 1 = n), ∃ β, CochainComplex.HomComplex.δ m n β = ↑α}, add_mem' := ⋯,
zero_mem' := ⋯, neg_mem... | null | true |
FreeAddGroup.reduceCyclically.reduce_flatten_replicate_succ | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} {L : List (α × Bool)} [inst : DecidableEq α],
FreeAddGroup.IsReduced L →
∀ (n : ℕ),
FreeAddGroup.reduce (List.replicate (n + 1) L).flatten =
FreeAddGroup.reduceCyclically.conjugator L ++
(List.replicate (n + 1) (FreeAddGroup.reduceCyclically L)).flatten ++
FreeAd... | null | true |
SubMulAction.algebraMap_mem | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
(algebraMap R A) r ∈ 1 | null | true |
IsCauSeq | Mathlib.Algebra.Order.CauSeq.Basic | {α : Type u_3} →
[inst : Field α] →
[inst_1 : LinearOrder α] → [IsStrictOrderedRing α] → {β : Type u_4} → [Ring β] → (β → α) → (ℕ → β) → Prop | A sequence is Cauchy if the distance between its entries tends to zero. | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.type?._sparseCasesOn_1 | Mathlib.Lean.Expr.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Order.Sublattice.0.Sublattice.le_prod_iff._simp_1_1 | Mathlib.Order.Sublattice | ∀ {A : Type u_1} {B : outParam (Type u_2)} {inst : Membership B A} {inst_1 : LE A} [self : IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
fderivWithin_csinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x | null | true |
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.Geometry.Manifold.ContMDiff.Constructions.0.contMDiffWithinAt_pi_iff._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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 |
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 |
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 |
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 |
IsNatCastApply.natCast_apply_eq_const | Mathlib.Algebra.Group.IsApply | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : NatCast F}
{inst_2 : NatCast β} [self : IsNatCastApply F α β] (n : ℕ) (x : α), ↑n x = ↑n | null | true |
Lean.Server.RequestCancellationToken._sizeOf_inst | Lean.Server.RequestCancellation | SizeOf Lean.Server.RequestCancellationToken | 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 |
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 |
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.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 |
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 |
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 |
Metric.ediam_image_le_iff | Mathlib.Topology.EMetricSpace.Diam | ∀ {α : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] [inst_1 : WeakPseudoEMetricSpace X] {d : ENNReal}
{f : α → X} {s : Set α}, Metric.ediam (f '' s) ≤ d ↔ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) ≤ d | null | true |
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 |
_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 |
Lean.Compiler.LCNF.Simp.State.simplified | Lean.Compiler.LCNF.Simp.SimpM | Lean.Compiler.LCNF.Simp.State → Bool | `true` if some simplification was performed in the current simplification pass.
| true |
Real.one_le_exp | Mathlib.Analysis.Complex.Exponential | ∀ {x : ℝ}, 0 ≤ x → 1 ≤ Real.exp x | null | 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 |
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 |
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 |
IsCoprime.isRelPrime | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {a b : R}, IsCoprime a b → IsRelPrime a b | null | true |
Lean.Compiler.LCNF.Simp.instInhabitedFunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfo | Inhabited Lean.Compiler.LCNF.Simp.FunDeclInfo | null | true |
_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 |
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 |
Lean.Compiler.LCNF.getSimpleGroundExpr | Lean.Compiler.LCNF.SimpleGroundExpr | Lean.Environment → Lean.Name → Option Lean.Compiler.LCNF.SimpleGroundExpr | Attempt to fetch a `SimpleGroundExpr` associated with `declName` if it exists.
| true |
_private.Mathlib.NumberTheory.Padics.PadicIntegers.0.PadicInt.coe_sum._simp_1_1 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]), ↑x = PadicInt.Coe.ringHom x | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.