name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Ideal.le_comap_pow_ramificationIdx | Mathlib.NumberTheory.RamificationInertia.Ramification | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R}
{P : Ideal S}, p ≤ Ideal.comap (algebraMap R S) (P ^ p.ramificationIdx P) | true |
Polynomial.natDegree_sub_eq_left_of_natDegree_lt | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R}, q.natDegree < p.natDegree → (p - q).natDegree = p.natDegree | true |
RingCon.instRingQuotient._proof_5 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Ring R] (c : RingCon R) (a : c.Quotient), -a + a = 0 | false |
_private.Mathlib.Topology.Closure.0.closure_eq_compl_interior_compl._simp_1_3 | Mathlib.Topology.Closure | ∀ {α : Type u_1} {s t : Set α}, (sᶜ ⊆ tᶜ) = (t ⊆ s) | false |
Finset.memberSubfamily_inter | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (𝒜 ℬ : Finset (Finset α)),
Finset.memberSubfamily a (𝒜 ∩ ℬ) = Finset.memberSubfamily a 𝒜 ∩ Finset.memberSubfamily a ℬ | true |
Std.LawfulIteratorLoop.mk | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {β α : Type w} {m : Type w → Type w'} {n : Type x → Type x'} [inst : Monad m] [inst_1 : Monad n]
[inst_2 : Std.Iterator α m β] [i : Std.IteratorLoop α m n],
(∀ (lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ) [Std.Internal.LawfulMonadLiftBindFunction lift]
(γ : Type x) (it : Std.IterM m β) (init... | true |
Lean.Syntax.Range.rec | Lean.Syntax | {motive : Lean.Syntax.Range → Sort u} →
((start stop : String.Pos.Raw) → motive { start := start, stop := stop }) → (t : Lean.Syntax.Range) → motive t | false |
OpenPartialHomeomorph.restrOpen.congr_simp | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e e_1 : OpenPartialHomeomorph X Y),
e = e_1 → ∀ (s s_1 : Set X) (e_s : s = s_1) (hs : IsOpen s), e.restrOpen s hs = e_1.restrOpen s_1 ⋯ | true |
CategoryTheory.Oplax.OplaxTrans.Hom.ctorIdx | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} → {η θ : F ⟶ G} → CategoryTheory.Oplax.OplaxTrans.Hom η θ → ℕ | false |
Hashable.ctorIdx | Init.Prelude | {α : Sort u} → Hashable α → ℕ | false |
NumberField.InfinitePlace.LiesOver.comap_eq | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(w : NumberField.InfinitePlace L) (v : NumberField.InfinitePlace K) [(↑w).LiesOver ↑v], w.comap (algebraMap K L) = v | true |
IntermediateField.algebra_adjoin_le_adjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E),
Algebra.adjoin F S ≤ (IntermediateField.adjoin F S).toSubalgebra | true |
Ordnode.dual_eraseMin._f | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (x : Ordnode α) (f : Ordnode.below x), x.eraseMin.dual = x.dual.eraseMax | false |
_private.Mathlib.Analysis.Convex.Radon.0.Convex.helly_theorem'._proof_1_3 | Mathlib.Analysis.Convex.Radon | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] (k : ℕ),
Module.finrank 𝕜 E + 1 ≤ k → ∀ {ι : Type u_1} {s : Finset ι}, s.card = k + 1 → s.card = k - 1 + 2 | false |
Lean.Compiler.LCNF.FixedParams.evalFVar | Lean.Compiler.LCNF.FixedParams | Lean.FVarId → Lean.Compiler.LCNF.FixedParams.FixParamM Lean.Compiler.LCNF.FixedParams.AbsValue | true |
Lean.JsonRpc.instOrdRequestID.ord | Lean.Data.JsonRpc | Lean.JsonRpc.RequestID → Lean.JsonRpc.RequestID → Ordering | true |
CategoryTheory.«_aux_Mathlib_CategoryTheory_Comma_Over_OverClass___macroRules_CategoryTheory_term_↘__1» | Mathlib.CategoryTheory.Comma.Over.OverClass | Lean.Macro | false |
FreeGroup.Red.inv_of_red_of_ne | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {x1 : α} {b1 : Bool} {x2 : α} {b2 : Bool},
(x1, b1) ≠ (x2, b2) → FreeGroup.Red ((x1, b1) :: L₁) ((x2, b2) :: L₂) → FreeGroup.Red L₁ ((x1, !b1) :: (x2, b2) :: L₂) | true |
himp_himp | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] (a b c : α), a ⇨ b ⇨ c = a ⊓ b ⇨ c | true |
CartanMatrix.dₙ | Mathlib.Algebra.Lie.SerreConstruction | (R : Type u_1) → [CommRing R] → ℕ → Type u_1 | true |
borel_eq_generateFrom_Ioc | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ (α : Type u_5) [inst : TopologicalSpace α] [SecondCountableTopology α] [inst_2 : LinearOrder α] [OrderTopology α],
borel α = MeasurableSpace.generateFrom {S | ∃ l u, l < u ∧ Set.Ioc l u = S} | true |
IntermediateField.LinearDisjoint.rank_right_mul_adjoin_rank_eq_of_isAlgebraic | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A : IntermediateField F E}
{L : Type v} [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E],
A.LinearDisjoint L →
Algebra.IsAlgebraic F ↥A ∨ Algebra.IsAlgebraic F L →
Module.... | true |
Std.Roo.Sliceable.mk._flat_ctor | Init.Data.Slice.Notation | {α : Type u} → {β : outParam (Type v)} → {γ : outParam (Type w)} → (α → Std.Roo β → γ) → Std.Roo.Sliceable α β γ | false |
_private.Mathlib.LinearAlgebra.Vandermonde.0.Matrix.det_vandermonde_ne_zero_iff._simp_1_4 | Mathlib.LinearAlgebra.Vandermonde | ∀ {a : Prop}, (¬¬a) = a | false |
Subgroup.coe_pathComponentOne | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G],
↑(Subgroup.pathComponentOne G) = pathComponent 1 | true |
NonarchAddGroupSeminorm.instOneOfDecidableEq | Mathlib.Analysis.Normed.Group.Seminorm | {E : Type u_3} → [inst : AddGroup E] → [DecidableEq E] → One (NonarchAddGroupSeminorm E) | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associated.prime.match_1_3 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {p q : M} (motive : Associated p q → Prop) (h : Associated p q),
(∀ (u : Mˣ) (hu : p * ↑u = q), motive ⋯) → motive h | false |
List.prefix_take_iff | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys : List α} {i : ℕ}, xs <+: List.take i ys ↔ xs <+: ys ∧ xs.length ≤ i | true |
Submodule.comm_trans_lTensorOne | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (M : Submodule R S),
TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne = M.rTensorOne | true |
MeasureTheory.Measure.mkMetric'_toOuterMeasure | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] (m : Set X → ENNReal),
(MeasureTheory.Measure.mkMetric' m).toOuterMeasure = (MeasureTheory.OuterMeasure.mkMetric' m).trim | true |
MulOpposite.instSemiring._proof_1 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : Semiring R] (a : Rᵐᵒᵖ), 1 * a = a | false |
LinearMap.IsContPerfPair.rec | Mathlib.Topology.Algebra.Module.PerfectPairing | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommRing R] →
[inst_1 : TopologicalSpace R] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : TopologicalSpace M] →
[inst_5 : AddCommGroup N] →
[inst_6 : Mod... | false |
KaehlerDifferential.mvPolynomialBasis | Mathlib.RingTheory.Kaehler.Polynomial | (R : Type u) → [inst : CommRing R] → (σ : Type u_1) → Module.Basis σ (MvPolynomial σ R) Ω[MvPolynomial σ R⁄R] | true |
tsum_apply | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {ι : Type u_4} {X : α → Type u_5} [inst : (x : α) → AddCommMonoid (X x)]
[inst_1 : (x : α) → TopologicalSpace (X x)] {L : SummationFilter ι} [L.NeBot] [∀ (x : α), T2Space (X x)]
{f : ι → (x : α) → X x} {x : α}, Summable f L → (∑'[L] (i : ι), f i) x = ∑'[L] (i : ι), f i x | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.map_mapToSubgraph_eq_induce.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (s : Set V) {u : V}
(motive : (v : V) → (x : G.Walk u v) → (∀ x_1 ∈ x.support, x_1 ∈ s) → Prop) (v : V) (x : G.Walk u v)
(x_1 : ∀ x_1 ∈ x.support, x_1 ∈ s),
(∀ (hs : ∀ x ∈ SimpleGraph.Walk.nil.support, x ∈ s), motive u SimpleGraph.Walk.nil hs) →
(∀ (v v_1 : V) (hadj : G.Ad... | false |
HahnSeries.toOrderTopSubOnePos.congr_simp | Mathlib.RingTheory.HahnSeries.Binomial | ∀ {Γ : Type u_1} {R : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] {x x_1 : HahnSeries Γ R} (e_x : x = x_1) (h : 0 < (x - 1).orderTop),
HahnSeries.toOrderTopSubOnePos h = HahnSeries.toOrderTopSubOnePos ⋯ | true |
CategoryTheory.RetractArrow.right | Mathlib.CategoryTheory.Retract | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z W : C} → {f : X ⟶ Y} → {g : Z ⟶ W} → CategoryTheory.RetractArrow f g → CategoryTheory.Retract Y W | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.forM_eq_forM_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
CategoryTheory.ShortComplex.mapOpcyclesIso_hom_naturality | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {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] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂)
(F : CategoryTheory.Functor C ... | true |
CategoryTheory.Comon.Hom.mk | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.Comon C} → (hom : M.X ⟶ N.X) → [isComonHom_hom : CategoryTheory.IsComonHom hom] → M.Hom N | true |
Lean.MessageLog.loggedKinds._default | Lean.Message | Lean.NameSet | false |
AlgebraicGeometry.Scheme.AffineCover.I₀ | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S : AlgebraicGeometry.Scheme} → AlgebraicGeometry.Scheme.AffineCover P S → Type v | true |
String.Pos.prev?.eq_1 | Init.Data.String.Termination | ∀ {s : String} (pos : s.Pos), pos.prev? = Option.map String.Pos.ofToSlice pos.toSlice.prev? | true |
_private.Std.Data.String.ToNat.0.String.Slice.isNat_iff'._simp_1_2 | Std.Data.String.ToNat | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | false |
Turing.ToPartrec.Code.succ_eval | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code.succ.eval = fun v => pure [v.headI.succ] | true |
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.interpCode.interpLetValue._unsafe_rec | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.UnreachableBranches.InterpM Lean.Compiler.LCNF.UnreachableBranches.Value | false |
CategoryTheory.Functor.WellOrderInductionData.ofExists | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | {J : Type u} →
[inst : LinearOrder J] →
[inst_1 : SuccOrder J] →
{F : CategoryTheory.Functor Jᵒᵖ (Type v)} →
(∀ (j : J), ¬IsMax j → Function.Surjective (F.map (CategoryTheory.homOfLE ⋯).op)) →
(∀ (j : J),
Order.IsSuccLimit j →
∀ (x : ↑(⋯.functor.op.comp F).sec... | true |
CategoryTheory.MonoidalClosed.unitNatIso | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)] →
CategoryTheory.Functor.id C ≅ CategoryTheory.ihom (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | true |
iteratedFDerivWithin_fun_zero | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {i : ℕ},
iteratedFDerivWithin 𝕜 i (fun x => 0) s = 0 | true |
AddSubmonoid.addSubmonoid_smul_sup | Mathlib.Algebra.Ring.Submonoid.Pointwise | ∀ {R : Type u_2} {A : Type u_3} [inst : AddMonoid R] [inst_1 : AddMonoid A] [inst_2 : DistribSMul R A]
{M : AddSubmonoid R} {N P : AddSubmonoid A}, M • (N ⊔ P) = M • N ⊔ M • P | true |
Valuation.instNonemptyUniformizer | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {K : Type u_2} [inst_1 : Field K] (v : Valuation K Γ)
[inst_2 : IsCyclic ↥(MonoidWithZeroHom.valueGroup v)] [inst_3 : Nontrivial ↥(MonoidWithZeroHom.valueGroup v)],
Nonempty v.Uniformizer | true |
Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {k a : α} {v : β k}, a ∈ Std.DTreeMap.Internal.Impl.insertIfNew! k v t → compare k a ≠ Ordering.eq → a ∈ t | true |
LocallyConstant.comap_injective | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y)),
Function.Surjective f.toFun → Function.Injective (LocallyConstant.comap f) | true |
NonUnitalAlgHom.coe_distribMulActionHom_mk | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} [inst : Monoid R] [inst_1 : Monoid S] {φ : R →* S} {A : Type v} {B : Type w}
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : DistribMulAction R A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction S B] (f : A →ₛₙₐ[φ] B) (h₁ : ∀ (m : R) (x : A), f (m • x) = φ m • f x)
... | true |
MeasureTheory.Filtration.instBot | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} → {ι : Type u_2} → {m : MeasurableSpace Ω} → [inst : Preorder ι] → Bot (MeasureTheory.Filtration ι m) | true |
List.Vector.mapAccumr_snoc | Mathlib.Data.Vector.Snoc | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} {n : ℕ} {x : α} (xs : List.Vector α n) {f : α → σ → σ × β} {s : σ},
List.Vector.mapAccumr f (xs.snoc x) s =
have q := f x s;
have r := List.Vector.mapAccumr f xs q.1;
(r.1, r.2.snoc q.2) | true |
Option.isNone_eq_false_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {a : Option α}, a.isNone = false ↔ a.isSome = true | true |
AlgebraicGeometry.Scheme.Cover.ofQuasiCompactCover_toPreZeroHypercover | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {S : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S)
[qc : AlgebraicGeometry.QuasiCompactCover 𝒰.toPreZeroHypercover],
𝒰.ofQuasiCompactCover.toPreZeroHypercover = 𝒰.toPreZeroHypercover | true |
CategoryTheory.op_epi_iff._simp_1 | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Epi f.op = CategoryTheory.Mono f | false |
FirstOrder.Language.constantsOnFunc | Mathlib.ModelTheory.LanguageMap | Type u' → ℕ → Type u' | true |
CommRingCat.moduleCatRestrictScalarsPseudofunctor_obj | Mathlib.Algebra.Category.ModuleCat.Pseudofunctor | ∀ (b : CategoryTheory.LocallyDiscrete CommRingCatᵒᵖ),
CommRingCat.moduleCatRestrictScalarsPseudofunctor.obj b = CategoryTheory.Cat.of (ModuleCat ↑(Opposite.unop b.as)) | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.BitVec.mkType | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Expr → Lean.Expr | true |
_private.Aesop.Frontend.Extension.0.Aesop.Frontend.addGlobalRule.match_1 | Aesop.Frontend.Extension | (motive : Lean.Meta.SimpEntry → Sort u_1) →
(e : Lean.Meta.SimpEntry) →
((l : Lean.Meta.SimpTheorem) → motive (Lean.Meta.SimpEntry.thm l)) →
((x : Lean.Meta.SimpEntry) → motive x) → motive e | false |
UpperHalfPlane.coe_im_pos | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (self : UpperHalfPlane), 0 < (↑self).im | true |
DirectLimit.instNonAssocRingOfRingHomClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → NonAssocRing (G i)]
[∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j),
NonUnitalRingHomClass (T h) (G i) (G j) | false |
tendsto_rpow_neg_nhdsGT_zero | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {y : ℝ}, y < 0 → Filter.Tendsto (fun x => x ^ y) (nhdsWithin 0 (Set.Ioi 0)) Filter.atTop | true |
TopologicalGroup.IsSES.integrate_apply | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {E : Type u_4} [inst : Group A] [inst_1 : Group B] [inst_2 : Group C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →* B} {ψ : B →* C}
(H : TopologicalGroup.IsSES φ ψ) [inst_6 : IsTopologicalGroup A] [inst_7 : IsTopolo... | true |
NonUnitalAlgHomClass.instSemilinearMapClassOfNonUnitalAlgSemiHomClassToMonoidHomRingHom | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {F : Type u_3} {R : Type u_4} {S : Type u_5} {A : Type u_6} {B : Type u_7} {x : Semiring R} {x_1 : Semiring S}
{φ : R →+* S} {x_2 : NonUnitalSemiring A} {x_3 : NonUnitalSemiring B} [inst : Module R A] [inst_1 : Module S B]
[inst_2 : FunLike F A B] [NonUnitalAlgSemiHomClass F (↑φ) A B], SemilinearMapClass F φ A B | true |
SmoothBumpFunction.le_one | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M}
(f : SmoothBumpFunction I c) {x : M} [inst_5 : FiniteDimensional ℝ E], ↑f x ≤ 1 | true |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.State.fields | Lean.Elab.Structure | Lean.Elab.Command.Structure.State✝ → Array Lean.Elab.Command.Structure.StructFieldInfo | true |
Sigma.rec.eq._@.Mathlib.Util.CompileInductive.4222055393._hygCtx._hyg.4 | Mathlib.Util.CompileInductive | @Sigma.rec = @Sigma.rec✝ | false |
Lean.Server.FileWorker.SignatureHelp.determineSignatureHelp | Lean.Server.FileWorker.SignatureHelp | Lean.Elab.InfoTree → Lean.Syntax → IO (Option Lean.Lsp.SignatureHelp) | true |
Module.Basis.equivFunL.congr_simp | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E]
[inst_5 : CompleteSpace 𝕜] {ι : Type u_1} [inst_6 : Finite ι] [inst_7 : T2Space E] (v v_1 : Module.Basis ι... | true |
Std.DHashMap.Internal.Raw₀.get! | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] → [LawfulBEq α] → [Hashable α] → Std.DHashMap.Internal.Raw₀ α β → (a : α) → [Inhabited (β a)] → β a | true |
ULift.module' | Mathlib.Algebra.Module.ULift | {R : Type u} →
{M : Type v} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [Module R M] → Module R (ULift.{u_1, v} M) | true |
Aesop.ScopeName.instOrd | Aesop.Rule.Name | Ord Aesop.ScopeName | true |
Graph.IsSubgraph.inc_congr | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β}, H ≤ G → e ∈ H.edgeSet → (H.Inc e x ↔ G.Inc e x) | true |
_private.Mathlib.RingTheory.Smooth.Fiber.0.Algebra.«term𝓀[_]» | Mathlib.RingTheory.Smooth.Fiber | Lean.ParserDescr | true |
Order.height_strictMono | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {x y : α}, x < y → Order.height x < ⊤ → Order.height x < Order.height y | true |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_3 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | false |
CommMonCat.hom_ext_iff | Mathlib.Algebra.Category.MonCat.Basic | ∀ {M N : CommMonCat} {f g : M ⟶ N}, f = g ↔ CommMonCat.Hom.hom f = CommMonCat.Hom.hom g | true |
Std.DTreeMap.Raw._auto_1 | Std.Data.DTreeMap.Raw.Basic | Lean.Syntax | false |
SeparationQuotient.lift₂ | Mathlib.Topology.Inseparable | {X : Type u_1} →
{Y : Type u_2} →
{α : Type u_4} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
(f : X → Y → α) →
(∀ (a : X) (b : Y) (c : X) (d : Y), Inseparable a c → Inseparable b d → f a b = f c d) →
SeparationQuotient X → SeparationQuotient Y ... | true |
CStarAlgebra.inv_le_inv_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b : Aˣ},
0 ≤ ↑a → 0 ≤ ↑b → (↑a⁻¹ ≤ ↑b⁻¹ ↔ ↑b ≤ ↑a) | true |
CommMonTypeEquivalenceCommMon.functor._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ (A : CategoryTheory.CommMon (Type u_1)), CategoryTheory.IsCommMonObj A.X | false |
Lean.Meta.TacticResultCNM.modified.noConfusion | Lean.Meta.Tactic.Util | {P : Sort u} →
{mvarId mvarId' : Lean.MVarId} →
Lean.Meta.TacticResultCNM.modified mvarId = Lean.Meta.TacticResultCNM.modified mvarId' → (mvarId = mvarId' → P) → P | false |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_gen.congr_simp | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F F_1 : Polynomial R} (e_F : F = F_1) {a a_1 : ℤ_[p]} (e_a : a = a_1)
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2) (n n_1 : ℕ),
n = n_1 → newton_seq_gen✝ hnorm n ... | true |
Mathlib.Meta.FunProp.betaThroughLet | Mathlib.Tactic.FunProp.ToBatteries | Lean.Expr → Array Lean.Expr → Lean.Expr | true |
Submodule.Quotient.instSMul'._proof_1 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {S : Type u_3}
[inst_3 : SMul S R] [inst_4 : SMul S M] [IsScalarTower S R M] (P : Submodule R M) (a : S) (x y : M),
P.quotientRel x y → -(fun x => a • x) x + (fun x => a • x) y ∈ P.toAddSubgroup | false |
CategoryTheory.Functor.functorHom_ext | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} {X : C} {x y : (F.functorHom G).obj X},
(∀ (Y : C) (f : X ⟶ Y), x.app Y f = y.app Y f) → x = y | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_erase._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Lean.Widget.RpcEncodablePacket.mk._@.Lean.Server.FileWorker.WidgetRequests.1564534894._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | Lean.Json → Lean.Json → Lean.Widget.RpcEncodablePacket✝ | false |
MvPowerSeries.WithPiTopology.summable_pow_of_constantCoeff_eq_zero | Mathlib.RingTheory.MvPowerSeries.PiTopology | ∀ {σ : Type u_1} {R : Type u_2} [inst : TopologicalSpace R] [inst_1 : Semiring R] {f : MvPowerSeries σ R},
MvPowerSeries.constantCoeff f = 0 → Summable fun x => f ^ x | true |
Algebra.Presentation.differentials.hom₁_single | Mathlib.Algebra.Module.Presentation.Differentials | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(pres : Algebra.Presentation R S ι σ) (r : σ),
((Algebra.Presentation.differentials.hom₁ pres) fun₀ | r => 1) = Algebra.Extension.Cotangent.mk ⟨pres.relation r, ⋯⟩ | true |
CategoryTheory.Pseudofunctor.Grothendieck.Hom.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{X Y : F.Grothendieck} →
{P : Sort u} →
{base : X.base ⟶ Y.base} →
{fiber : (F.map base.toLoc).toFunctor.obj X.fiber ⟶ Y.f... | false |
Nat.toArray_rco_eq_singleton | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, n = m + 1 → (m...n).toArray = #[m] | true |
_private.Mathlib.Topology.Compactness.SigmaCompact.0.CompactExhaustion.mem_diff_shiftr_find._simp_1_2 | Mathlib.Topology.Compactness.SigmaCompact | ∀ (n : ℕ), (n < n.succ) = True | false |
_private.Mathlib.Util.Superscript.0.Mathlib.Tactic.Superscript.scriptParser.formatter.match_1 | Mathlib.Util.Superscript | (motive : Option (List Char) → Sort u_1) →
(x : Option (List Char)) → ((s : List Char) → motive (some s)) → ((x : Option (List Char)) → motive x) → motive x | false |
RingHom.injective | Mathlib.RingTheory.SimpleRing.Basic | ∀ {R : Type u_2} {S : Type u_3} [inst : NonAssocRing R] [IsSimpleRing R] [inst_2 : NonAssocSemiring S] [Nontrivial S]
(f : R →+* S), Function.Injective ⇑f | true |
Ordering.gt.sizeOf_spec | Init.Data.Ord.Basic | sizeOf Ordering.gt = 1 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.