name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.String.Lemmas.Pattern.Split.0.String.Slice.Pattern.Model.splitFromSteps.match_1.eq_2 | Init.Data.String.Lemmas.Pattern.Split | ∀ {s : String.Slice} (motive : List (String.Slice.Pattern.SearchStep s) → Sort u_1) (startPos endPos : s.Pos)
(l : List (String.Slice.Pattern.SearchStep s)) (h_1 : Unit → motive [])
(h_2 :
(startPos endPos : s.Pos) →
(l : List (String.Slice.Pattern.SearchStep s)) →
motive (String.Slice.Pattern.Sea... | true |
ENNReal.orderIsoUnitIntervalBirational | Mathlib.Data.ENNReal.Inv | ENNReal ≃o ↑(Set.Icc 0 1) | true |
Homeomorph.Set.prod._proof_1 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} (s : Set X) (t : Set Y) (x : { x // x ∈ s ×ˢ t }), (↑x).1 ∈ s | false |
SemiRingCat.limitSemiring._proof_18 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt), a * 0 = 0 | false |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.compileToSimpleGroundExpr.compileArgs | Lean.Compiler.IR.SimpleGroundExpr | Array Lean.IR.Arg → Lean.IR.M✝ (Array Lean.IR.SimpleGroundArg) | true |
DividedPowers.SubDPIdeal.mk.congr_simp | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} (carrier carrier_1 : Ideal A)
(e_carrier : carrier = carrier_1) (isSubideal : carrier ≤ I)
(dpow_mem : ∀ (n : ℕ), n ≠ 0 → ∀ j ∈ carrier, hI.dpow n j ∈ carrier),
{ carrier := carrier, isSubideal := isSubideal, dpow_mem := dpow_mem } =
... | true |
SSet.PtSimplex | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | (X : SSet) → ℕ → X.obj (Opposite.op (SimplexCategory.mk 0)) → Type u | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone.0.NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates_eq_iff.match_1_6 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(a b : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)) (motive : (∃ ζ, ↑ζ • ↑a = ↑b) → Prop)
(x : ∃ ζ, ↑ζ • ↑a = ↑b),
(∀ (u : (NumberField.RingOfIntegers K)ˣ) (property : u ∈ NumberField.Units.torsion K) (h : ↑⟨u, property⟩ • ↑a = ↑b),
m... | false |
AlgebraicTopology.map_alternatingFaceMapComplex | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
(AlgebraicTopology.alternatingFaceMapComplex C).comp... | true |
iteratedDerivWithin_of_isOpen_eq_iterate | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F} {s : Set 𝕜},
IsOpen s → Set.EqOn (iteratedDerivWithin n f s) (deriv^[n] f) s | true |
Lean.PersistentHashMap.Stats._sizeOf_inst | Lean.Data.PersistentHashMap | SizeOf Lean.PersistentHashMap.Stats | false |
IsometryEquiv.mk.noConfusion | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} →
{β : Type v} →
{inst : PseudoEMetricSpace α} →
{inst_1 : PseudoEMetricSpace β} →
{P : Sort u_1} →
{toEquiv : α ≃ β} →
{isometry_toFun : Isometry toEquiv.toFun} →
{toEquiv' : α ≃ β} →
{isometry_toFun' : Isometry toEquiv'.toFun} →
... | false |
CategoryTheory.Functor.mapAddMon_map_hom | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] {X Y : CategoryTheory.AddMon C} (f : X ⟶ Y),
(... | true |
StateCpsT.runK_bind_pure | Init.Control.StateCps | ∀ {α σ : Type u} {m : Type u → Type v} {β γ : Type u} (a : α) (f : α → StateCpsT σ m β) (s : σ) (k : β → σ → m γ),
(pure a >>= f).runK s k = (f a).runK s k | true |
LieHom.toLinearMap_comp._simp_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [inst : CommRing R] [inst_1 : LieRing L₁]
[inst_2 : LieAlgebra R L₁] [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] [inst_5 : LieRing L₃]
[inst_6 : LieAlgebra R L₃] (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂), ↑f ∘ₗ ↑g = ↑(f.comp g) | false |
Std.Do.SPred.Tactic.instIsPureImpPureForall | Std.Do.SPred.DerivedLaws | ∀ {φ ψ : Prop} (σs : List (Type u_1)), Std.Do.SPred.Tactic.IsPure spred(⌜φ⌝ → ⌜ψ⌝) (φ → ψ) | true |
Equiv.pointReflection_midpoint_right | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] (x y : P), (Equiv.pointReflection (midpoint R x y)) y = x | true |
BiheytingAlgebra.ctorIdx | Mathlib.Order.Heyting.Basic | {α : Type u_4} → BiheytingAlgebra α → ℕ | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Const.0.differentiableAt_of_fderiv_injective._simp_1_2 | 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}, fderiv 𝕜 f = fderivWithin 𝕜 f Set.univ | false |
AlgebraicGeometry.Scheme.residueFieldCongr | Mathlib.AlgebraicGeometry.ResidueField | {X : AlgebraicGeometry.Scheme} → {x y : ↥X} → x = y → (X.residueField x ≅ X.residueField y) | true |
CategoryTheory.MorphismProperty.HasLocalization.noConfusionType | Mathlib.CategoryTheory.Localization.HasLocalization | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
W.HasLocalization →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{W' : CategoryTheory.MorphismProperty C'} → W'.HasLocalization → Sort ... | false |
Lean.Server.MonadCancellable.noConfusionType | Lean.Server.RequestCancellation | Sort u →
{m : Type → Type v} → Lean.Server.MonadCancellable m → {m' : Type → Type v} → Lean.Server.MonadCancellable m' → Sort u | false |
LinearMap.prod_eq_inf_comap | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (p : Submodule R M) (q : Submodule R M₂),
p.prod q = Submodule.comap (LinearMap.fst R M M₂) p ⊓ Submodule.comap (LinearMap.snd R M M₂) q | true |
Std.TreeSet.getD_eq_fallback | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getD a fallback = fallback | true |
LSeriesHasSum.smul | Mathlib.NumberTheory.LSeries.Linearity | ∀ {f : ℕ → ℂ} (c : ℂ) {s a : ℂ}, LSeriesHasSum f s a → LSeriesHasSum (c • f) s (c * a) | true |
CategoryTheory.WithTerminal.comp.match_1 | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u_1} →
(motive : CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → Sort u_2) →
(x x_1 x_2 : CategoryTheory.WithTerminal C) →
((_X _Y _Z : C) →
motive (CategoryTheory.WithTerminal.of _X) (CategoryTheory.WithTerminal.of _Y)
(Categor... | false |
Lean.Lsp.InitializationOptions.hasWidgets? | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializationOptions → Option Bool | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point.0.WeierstrassCurve.Jacobian.Point.toAffine_some._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} (a b c : R), ![a, b, c] 0 = a | false |
Filter.Tendsto.atTop_of_add_le_const | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelAddMonoid M]
{l : Filter α} {f g : α → M},
(∃ C, ∀ (x : α), g x ≤ C) → Filter.Tendsto (fun x => f x + g x) l Filter.atTop → Filter.Tendsto f l Filter.atTop | true |
groupCohomology.coboundaries₁_le_cocycles₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{max u u_1, u, u} k G),
groupCohomology.coboundaries₁ A ≤ groupCohomology.cocycles₁ A | true |
Padic.limSeq | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [inst : Fact (Nat.Prime p)] → CauSeq ℚ_[p] ⇑padicNormE → ℕ → ℚ | true |
Vector.eq_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {xs : Vector α 0}, xs = #v[] | true |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.Grading.0.ExteriorAlgebra.ιMulti_span.match_1_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Grading | ∀ (R : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {i : ℕ}
(motive : ↥(⋀[R]^i M) → Prop) (hm : ↥(⋀[R]^i M)),
(∀ (m : ExteriorAlgebra R M) (hm : m ∈ ⋀[R]^i M), motive ⟨m, hm⟩) → motive hm | false |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.explainMutualFailure.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | (motive : Array (Array String) × String → Sort u_1) →
(__discr : Array (Array String) × String) →
((headerss : Array (Array String)) → (footer : String) → motive (headerss, footer)) → motive __discr | false |
Lean.Meta.instReduceEvalUInt64_qq | Qq.ForLean.ReduceEval | Lean.Meta.ReduceEval UInt64 | true |
Std.Iterators.Types.Zip.right | Std.Data.Iterators.Combinators.Monadic.Zip | {α₁ : Type w} →
{m : Type w → Type w'} →
{β₁ : Type w} →
[inst : Std.Iterator α₁ m β₁] → {α₂ β₂ : Type w} → Std.Iterators.Types.Zip α₁ m α₂ β₂ → Std.IterM m β₂ | true |
Vector.eraseIdx_append_of_lt_size._proof_2 | Init.Data.Vector.Erase | ∀ {n k : ℕ}, k < n → n - 1 + n = n + n - 1 | false |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalUnaryBitVec'.match_1 | Lean.Meta.Sym.Simp.EvalGround | (motive : OptionT Id Lean.Meta.Sym.BitVecValue → Sort u_1) →
(x : OptionT Id Lean.Meta.Sym.BitVecValue) →
((a : Lean.Meta.Sym.BitVecValue) → motive (some a)) →
((x : OptionT Id Lean.Meta.Sym.BitVecValue) → motive x) → motive x | false |
Matrix.IsAdjMatrix.toGraph_adj | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} {A : Matrix V V α} [inst : MulZeroOneClass α] [inst_1 : Nontrivial α]
(h : A.IsAdjMatrix) (i j : V), h.toGraph.Adj i j = (A i j = 1) | true |
Function.Surjective.moduleLeft._proof_3 | Mathlib.Algebra.Module.RingHom | ∀ {R : Type u_3} {S : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Semiring S] [inst_4 : SMul S M] (f : R →+* S) (hf : Function.Surjective ⇑f)
(hsmul : ∀ (c : R) (x : M), f c • x = c • x) (y₁ y₂ : S) (x : M), (y₁ + y₂) • x = y₁ • x + y₂ • x | false |
Std.HashMap.getKeyD_alter_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[Inhabited α] {k fallback : α} {f : Option β → Option β},
(m.alter k f).getKeyD k fallback = if (f m[k]?).isSome = true then k else fallback | true |
TopModuleCat.isColimitCoker._proof_4 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N)
(s : CategoryTheory.Limits.CokernelCofork φ), ContinuousSMul R ↑s.1.toModuleCat | false |
ValuationRing.iff_dvd_total | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R], ValuationRing R ↔ Std.Total fun x1 x2 => x1 ∣ x2 | true |
disjointed_add_one | Mathlib.Algebra.Order.Disjointed | ∀ {α : Type u_1} {ι : Type u_2} [inst : GeneralizedBooleanAlgebra α] [inst_1 : LinearOrder ι]
[inst_2 : LocallyFiniteOrderBot ι] [inst_3 : Add ι] [inst_4 : One ι] [SuccAddOrder ι] [NoMaxOrder ι] (f : ι → α)
(i : ι), disjointed f (i + 1) = f (i + 1) \ (partialSups f) i | true |
MulEquiv.mapSubgroup.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {H : Type u_6} [inst_1 : Group H] (f : G ≃* H),
f.mapSubgroup =
{ toFun := Subgroup.map ↑f, invFun := Subgroup.map ↑f.symm, left_inv := ⋯, right_inv := ⋯, map_rel_iff' := ⋯ } | true |
Lean.Lsp.ShowDocumentClientCapabilities | Lean.Data.Lsp.Capabilities | Type | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.exists_le_of_le._proof_1_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a b : α} {P Q : Finpartition a},
(∀ p ∈ P.parts, ∃ q ∈ Q.parts.erase b, p ≤ q) → P.parts.sup id ≤ (Q.parts.erase b).sup id | false |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.finite_finsupp_iff._simp_1_4 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {α : Type u_1}, (¬Subsingleton α) = Nontrivial α | false |
MeasureTheory.Measure.isOpenPosMeasure_smul | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) [μ.IsOpenPosMeasure]
{c : ENNReal}, c ≠ 0 → (c • μ).IsOpenPosMeasure | true |
SimpleGraph.Finsubgraph.coe_compl._simp_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {G : SimpleGraph V} [inst : Finite V] (G' : G.Finsubgraph), (↑G')ᶜ = ↑G'ᶜ | false |
_private.Mathlib.CategoryTheory.NatTrans.0.CategoryTheory.NatTrans.ext.match_1 | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u_3} {inst : CategoryTheory.Category.{u_1, u_3} C} {D : Type u_4}
{inst_1 : CategoryTheory.Category.{u_2, u_4} D} {F G : CategoryTheory.Functor C D}
(motive : CategoryTheory.NatTrans F G → Prop) (h : CategoryTheory.NatTrans F G),
(∀ (app : (X : C) → F.obj X ⟶ G.obj X)
(naturality :
autoP... | false |
Lean.IR.ExpandResetReuse.removeSelfSet | Lean.Compiler.IR.ExpandResetReuse | Lean.IR.ExpandResetReuse.Context → Lean.IR.FnBody → Lean.IR.FnBody | true |
CategoryTheory.Localization.instHasSmallLocalizedHomObjShiftFunctor | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (W : CategoryTheory.MorphismProperty C) {M : Type w'}
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] (X Y : C)
[CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y] (m : M),
CategoryTheory.Localization.HasSmallLocalizedHom W X ... | true |
Lean.Meta.Hint.Suggestion | Lean.Meta.Hint | Type | true |
_private.Mathlib.MeasureTheory.Function.LpSpace.Basic.0.MeasureTheory.Lp.instNormedAddCommGroup._simp_3 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {r q : NNReal}, (↑r ≤ ↑q) = (r ≤ q) | false |
Quaternion.instRing._proof_45 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | false |
OpenPartialHomeomorph.subtypeRestr_source | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : TopologicalSpace.Opens X} (hs : Nonempty ↥s),
(e.subtypeRestr hs).source = Subtype.val ⁻¹' e.source | true |
AddMonoidAlgebra.mapDomain.eq_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] (f : M → N) (x : AddMonoidAlgebra R M),
AddMonoidAlgebra.mapDomain f x = Finsupp.mapDomain f x | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processCtorApp._sparseCasesOn_1 | Lean.Elab.PatternVar | {motive : Lean.Elab.Term.Arg → Sort u} →
(t : Lean.Elab.Term.Arg) →
((val : Lean.Syntax) → motive (Lean.Elab.Term.Arg.stx val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Int.Linear.orOver_one | Init.Data.Int.Linear | ∀ {p : ℕ → Prop}, Int.Linear.OrOver 1 p → p 0 | true |
CategoryTheory.GlueData.mapGlueData._proof_6 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {C' : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C')
[inst_2 : ∀ (i j k : D.J), CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F]
(i... | false |
_private.Mathlib.Order.Fin.Tuple.0.Fin.preimage_insertNth_Icc_of_notMem._simp_1_1 | Mathlib.Order.Fin.Tuple | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
_private.Mathlib.LinearAlgebra.Dimension.DivisionRing.0.rank_add_rank_split._simp_1_2 | Mathlib.LinearAlgebra.Dimension.DivisionRing | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | false |
WeierstrassCurve.Jacobian.fin3_def_ext | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} (a b c : R), ![a, b, c] 0 = a ∧ ![a, b, c] 1 = b ∧ ![a, b, c] 2 = c | true |
Hyperreal.Infinitesimal | Mathlib.Analysis.Real.Hyperreal | ℝ* → Prop | true |
LinearPMap._sizeOf_inst | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
{inst : Ring R} →
{inst_1 : Ring S} →
(σ : R →+* S) →
(E : Type u_3) →
{inst_2 : AddCommGroup E} →
{inst_3 : Module R E} →
(F : Type u_4) →
{inst_4 : AddCommGroup F} →
{inst_5 ... | false |
hfdifferential._proof_2 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_2}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | false |
_private.Aesop.Forward.State.0.Aesop.instBEqRawHyp.beq._sparseCasesOn_2 | Aesop.Forward.State | {motive : Aesop.RawHyp → Sort u} →
(t : Aesop.RawHyp) →
((subst : Aesop.Substitution) → motive (Aesop.RawHyp.patSubst subst)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Finpartition.casesOn | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{a : α} →
{motive : Finpartition a → Sort u} →
(t : Finpartition a) →
((parts : Finset α) →
(supIndep : parts.SupIndep id) →
(sup_parts : parts.sup id = a) →
(bot... | false |
CategoryTheory.Bicategory.Adj.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | {P : Sort u_1} →
{B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : B} →
{t : CategoryTheory.Bicategory.Adj.Hom a b} →
{B' : Type u} →
{inst' : CategoryTheory.Bicategory B'} →
{a' b' : B'} →
{t' : CategoryTheory.Bicategory.Adj.Hom a' b'} ... | false |
Lean.Grind.CommRing.instBEqPoly.beq._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Bool | false |
CategoryTheory.Adjunction.conesIsoComponentHom._proof_1 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] {K : CategoryTheory.Functor J D}
(X : Cᵒᵖ) (t... | false |
primorial_one | Mathlib.NumberTheory.Primorial | primorial 1 = 1 | true |
ENormedAddMonoid.enorm_eq_zero | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_8} {inst : TopologicalSpace E} [self : ENormedAddMonoid E] (x : E), ‖x‖ₑ = 0 ↔ x = 0 | true |
Lean.Meta.Omega.OmegaConfig.mk | Init.Meta.Defs | Bool → Bool → Bool → Bool → Lean.Meta.Omega.OmegaConfig | true |
Std.ExtTreeMap.isSome_maxKey?_modify_eq_isSome | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{f : β → β}, (t.modify k f).maxKey?.isSome = t.maxKey?.isSome | true |
CategoryTheory.ULift.equivalence_functor | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.ULift.equivalence.functor = CategoryTheory.ULift.upFunctor | true |
Lean.ImportArtifacts.ofArray | Lean.Setup | Array System.FilePath → Lean.ImportArtifacts | true |
ContinuousLinearMap.flipMultilinear._proof_6 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_3} {ι : Type u_4} {E : ι → Type u_5} {G : Type u_1} {G' : Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | false |
MonCat.of | Mathlib.Algebra.Category.MonCat.Basic | (M : Type u) → [Monoid M] → MonCat | true |
Std.DTreeMap.Raw.getKey!_diff_of_not_mem_right | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [inst : Inhabited α]
[Std.TransCmp cmp], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₂ → (t₁ \ t₂).getKey! k = t₁.getKey! k | true |
Int16.toBitVec_div | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a / b).toBitVec = a.toBitVec.sdiv b.toBitVec | true |
Filter.not_bddBelow_of_tendsto_atBot | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {l : Filter α} [l.NeBot] {f : α → β} [NoMinOrder β],
Filter.Tendsto f l Filter.atBot → ¬BddBelow (Set.range f) | true |
entourageProd.match_1 | Mathlib.Topology.UniformSpace.Basic | {α : Type u_2} →
{β : Type u_1} →
(motive : (α × β) × α × β → Sort u_3) →
(x : (α × β) × α × β) → ((a₁ : α) → (b₁ : β) → (a₂ : α) → (b₂ : β) → motive ((a₁, b₁), a₂, b₂)) → motive x | false |
MeasureTheory.Measure.NullMeasurableSet.const_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] {μ : MeasureTheory.Measure E} [μ.IsAddHaarMeasure] {s : Set E},
MeasureTheory.NullMeasurableSet s μ → ∀ (r : ℝ), MeasureTheory.NullMeasurableSet (r • s) μ | true |
CategoryTheory.Enriched.FunctorCategory.functorEnrichedCategory._proof_2 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V]
(C : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} C] (J : Type u_3)
[inst_3 : CategoryTheory.Category.{u_1, u_3} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
[inst_5 :
∀ (F₁ F₂ : ... | false |
Lean.Lsp.RpcCallParams.mk._flat_ctor | Lean.Data.Lsp.Extra | Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.Position → UInt64 → Lean.Name → Lean.Json → Lean.Lsp.RpcCallParams | false |
Int.tdiv_dvd_tdiv | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b → b ∣ c → b.tdiv a ∣ c.tdiv a | true |
Std.Tactic.BVDecide.BVBinPred.ult | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinPred | true |
_private.Lean.Meta.Basic.0.Lean.Meta.exposeRelevantUniverses._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 24 t.ctorIdx → motive t) → motive t | false |
GroupCone.mk.injEq | Mathlib.Algebra.Order.Group.Cone | ∀ {G : Type u_1} [inst : CommGroup G] (toSubmonoid : Submonoid G)
(eq_one_of_mem_of_inv_mem' : ∀ {a : G}, a ∈ toSubmonoid.carrier → a⁻¹ ∈ toSubmonoid.carrier → a = 1)
(toSubmonoid_1 : Submonoid G)
(eq_one_of_mem_of_inv_mem'_1 : ∀ {a : G}, a ∈ toSubmonoid_1.carrier → a⁻¹ ∈ toSubmonoid_1.carrier → a = 1),
({ toSu... | true |
Set.BijOn.ncard_eq | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {t : Set β}, Set.BijOn f s t → s.ncard = t.ncard | true |
YoungDiagram.transpose_eq_iff | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ.transpose = ν.transpose ↔ μ = ν | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux.handleEnumWithDefault.intersperseDefault | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.InductiveVal →
Lean.Expr → List Lean.Level → List (ℕ × Lean.Expr) → ℕ → List (ℕ × Lean.Expr) → Lean.MetaM (List (ℕ × Lean.Expr)) | true |
Nat.floor_sub_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
[inst_4 : Sub R] [OrderedSub R] [ExistsAddOfLE R] (a : R) (n : ℕ) [inst_7 : n.AtLeastTwo],
⌊a - OfNat.ofNat n⌋₊ = ⌊a⌋₊ - OfNat.ofNat n | true |
WeierstrassCurve.Ψ₂Sq._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | (3 + 1).AtLeastTwo | false |
Aesop.SafeRulesResult.ctorElimType | Aesop.Search.Expansion | {motive : Aesop.SafeRulesResult → Sort u} → ℕ → Sort (max 1 u) | false |
Std.Rcc.pairwise_toList_le | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [LT α] [inst_3 : Std.PRange.UpwardEnumerable α]
[inst_4 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_6 : Std.Rxc.IsAlwaysFinite α], List.Pairwise (fun a b => a ≤ b) r.toList | true |
Mathlib.Ineq.WithStrictness.casesOn | Mathlib.Tactic.LinearCombination.Lemmas | {motive : Mathlib.Ineq.WithStrictness → Sort u} →
(t : Mathlib.Ineq.WithStrictness) →
motive Mathlib.Ineq.WithStrictness.eq →
motive Mathlib.Ineq.WithStrictness.le →
((strict : Bool) → motive (Mathlib.Ineq.WithStrictness.lt strict)) → motive t | false |
CategoryTheory.CommGrp._sizeOf_inst | Mathlib.CategoryTheory.Monoidal.CommGrp_ | (C : Type u₁) →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} → [SizeOf C] → SizeOf (CategoryTheory.CommGrp C) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.