name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
WithBot.instIsOrderedRing | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α] [IsOrderedRing α]
[inst_4 : CanonicallyOrderedAdd α] [inst_5 : NoZeroDivisors α] [inst_6 : Nontrivial α], IsOrderedRing (WithBot α) | true |
Batteries.RBNode.Path.insertNew.eq_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} (path : Batteries.RBNode.Path α) (v : α),
path.insertNew v = path.ins (Batteries.RBNode.node Batteries.RBColor.red Batteries.RBNode.nil v Batteries.RBNode.nil) | true |
Batteries.RBNode.setRed.eq_2 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1}, Batteries.RBNode.nil.setRed = Batteries.RBNode.nil | true |
Algebra.TensorProduct.tensorTensorTensorComm_symm | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type uR} {R' : Type u_1} {S : Type uS} {T : Type u_2} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD}
[inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : Semiring A] [inst_4 : Algebra R A]
[inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] [inst_7 : Semiring B] [inst... | true |
UInt8.sub_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, b ≤ a → a - b ≤ a | true |
RingCat.Colimits.Prequotient.ctorElim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J RingCat} →
{motive : RingCat.Colimits.Prequotient F → Sort u} →
(ctorIdx : ℕ) →
(t : RingCat.Colimits.Prequotient F) →
ctorIdx = t.ctorIdx → RingCat.Colimits.Prequotient.ctorElimType ctorIdx ... | false |
AbsoluteValue.isAbsoluteValue | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R]
(abv : AbsoluteValue R S), IsAbsoluteValue ⇑abv | true |
Matroid.Indep.rankPos_of_nonempty | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → I.Nonempty → M.RankPos | true |
MeasureTheory.hausdorffMeasure_smul | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {α : Type u_4}
[inst_3 : SMul α X] [IsIsometricSMul α X] {d : ℝ} (c : α),
(0 ≤ d ∨ Function.Surjective fun x => c • x) →
∀ (s : Set X), (MeasureTheory.Measure.hausdorffMeasure d) (c • s) = (MeasureTheory.Measure.hausdo... | true |
Std.TreeMap.minKey!_modify | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{k : α} {f : β → β},
(t.modify k f).isEmpty = false → (t.modify k f).minKey! = if cmp t.minKey! k = Ordering.eq then k else t.minKey! | true |
Std.Time.PlainDateTime.mk.sizeOf_spec | Std.Time.DateTime.PlainDateTime | ∀ (date : Std.Time.PlainDate) (time : Std.Time.PlainTime),
sizeOf { date := date, time := time } = 1 + sizeOf date + sizeOf time | true |
Lean.Grind.Ring.intCast_zero | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α], ↑0 = 0 | true |
Finset.Nonempty.of_smul_left | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] {s : Finset α} {t : Finset β},
(s • t).Nonempty → s.Nonempty | true |
CategoryTheory.AdditiveFunctor.ofLeftExact_map | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasZeroObject C] [inst_5 : CategoryTheory.Limits.HasZeroObject D]
[inst_6 : Catego... | true |
lt_or_le_of_codirected | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] {r v₁ v₂ : α},
r ≤ v₁ → r ≤ v₂ → v₁ < v₂ ∨ v₂ ≤ v₁ | true |
Lean.Meta.Sym.Simp.Result.rfl.injEq | Lean.Meta.Sym.Simp.SimpM | ∀ (done done_1 : Bool), (Lean.Meta.Sym.Simp.Result.rfl done = Lean.Meta.Sym.Simp.Result.rfl done_1) = (done = done_1) | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.Point.toClass.match_1.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} (motive : W.Point → Sort u_2)
(h_1 : Unit → motive WeierstrassCurve.Affine.Point.zero)
(h_2 : (x y : F) → (h : W.Nonsingular x y) → motive (WeierstrassCurve.Affine.Point.some x y h)),
(match WeierstrassCurve.Affine.Point.zero with
| Weierstrass... | true |
Algebra.adjoin_insert_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : Set A) (x : A),
Algebra.adjoin R (insert x ↑(Algebra.adjoin R s)) = Algebra.adjoin R (insert x s) | true |
Lean.Elab.Term.MVarErrorKind._sizeOf_inst | Lean.Elab.Term.TermElabM | SizeOf Lean.Elab.Term.MVarErrorKind | false |
GrpCat.limitCone | Mathlib.Algebra.Category.Grp.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J GrpCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget GrpCat)).sections] → CategoryTheory.Limits.Cone F | true |
Batteries.Tactic.getExplicitRelArg?._sunfold | Batteries.Tactic.Trans | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) | false |
Real.rpow_sum_le_const_mul_sum_rpow_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) {f : ι → ℝ} {p : ℝ},
1 ≤ p → (∀ i ∈ s, 0 ≤ f i) → (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p | true |
String.Pos.Raw.byteIdx_add_string | Init.Data.String.PosRaw | ∀ {p : String.Pos.Raw} {s : String}, (p + s).byteIdx = p.byteIdx + s.utf8ByteSize | true |
MonCat.Colimits.colimitIsColimit._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (m : (MonCat.Colimits.colimitCocone F).pt ⟶ s.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp ((MonCat.Colimits.colimitCocone F).ι.app j) m = s.ι.app j) →
m = MonCat.Coli... | false |
instHasColimitsOfShapeUnderOfWithInitial | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
(X : C) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.WithInitial J) C],
CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.Under X) | true |
ContMDiffAt.curry_left | 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... | true |
LaurentPolynomial.degree_zero | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R], LaurentPolynomial.degree 0 = ⊥ | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_1.splitter | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound | {n : ℕ} →
(motive : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool → Sort u_1) →
(x : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool) →
((fst : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) →
(checkSuccess : Bool) → motive (fst, checkSuccess)) →
motive x | true |
PNat.factorMultiset.eq_1 | Mathlib.Data.PNat.Factors | ∀ (n : ℕ+), n.factorMultiset = PrimeMultiset.ofNatList (↑n).primeFactorsList ⋯ | true |
CategoryTheory.Grothendieck.instCategory._proof_3 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (f : X.Hom Y), CategoryTheory.Grothendieck.comp X.id f = f | false |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_eq_zero.match_1_1 | Init.Data.Nat.Lemmas | ∀ (n n_1 : ℕ) (motive : (n_1 + 1) * (n + 1) = 0 → Prop) (a : (n_1 + 1) * (n + 1) = 0), motive a | false |
Submonoid.map_inf_comap_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F},
Function.Surjective ⇑f → ∀ (S T : Submonoid N), Submonoid.map f (Submonoid.comap f S ⊓ Submonoid.comap f T) = S ⊓ T | true |
CStarModule.inner_zero_left | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [StarModule ℂ A] {x : E}, inner A 0 x = 0 | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry_congr._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getEntry a l h) = Std.Internal.List.getEntry? a l | false |
Lean.Grind.AC.Seq.collectVars._sunfold | Lean.Meta.Tactic.Grind.AC.VarRename | Lean.Grind.AC.Seq → Lean.Meta.Grind.VarCollector | false |
Matrix.kroneckerBilinear._proof_3 | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {R : Type u_2} {α : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring α] [inst_2 : Algebra R α],
LinearMapClass (α →ₐ[R] Module.End R α) R α (Module.End R α) | false |
Int.fmod_eq_emod | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a.fmod b = a % b + if 0 ≤ b ∨ b ∣ a then 0 else b | true |
_private.Init.Data.String.Basic.0.String.Pos.Raw.offsetOfPosAux._unary._proof_1 | Init.Data.String.Basic | ∀ (s : String) (i : String.Pos.Raw),
¬String.Pos.Raw.atEnd s i = true → s.utf8ByteSize - (String.Pos.Raw.next s i).byteIdx < s.utf8ByteSize - i.byteIdx | false |
ContinuousLinearEquiv.toLinearEquiv | Mathlib.Topology.Algebra.Module.Equiv | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
{σ' : S →+* R} →
[inst_2 : RingHomInvPair σ σ'] →
[inst_3 : RingHomInvPair σ' σ] →
{M : Type u_3} →
[inst_4 : TopologicalSpace M] →
... | true |
ProofWidgets.MarkdownDisplay.Props.mk | ProofWidgets.Component.Basic | String → ProofWidgets.MarkdownDisplay.Props | true |
Batteries.RBNode.Path.zoom_fill | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α}
{t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α},
Batteries.RBNode.zoom cut t path = (t', path') → path.fill t = path'.fill t' | true |
CategoryTheory.Presieve.functorPushforward | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → {X : C} → CategoryTheory.Presieve X → CategoryTheory.Presieve (F.obj X) | true |
SimplexCategory.Truncated.Hom.tr_id | Mathlib.AlgebraicTopology.SimplexCategory.Defs | ∀ {n : ℕ} (a : SimplexCategory) (ha : autoParam (a.len ≤ n) SimplexCategory.Truncated.Hom.tr_id._auto_1),
SimplexCategory.Truncated.Hom.tr (CategoryTheory.CategoryStruct.id a) ha ha =
CategoryTheory.CategoryStruct.id { obj := a, property := ha } | true |
ProbabilityTheory.Kernel.densityProcess_empty | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β))
(ν : ProbabilityTheory.Kernel α γ) (n : ℕ) (a : α) (x : γ), κ.densityProcess ν n a x ∅ = 0 | true |
Lean.Elab.FVarAliasInfo.mk | Lean.Elab.InfoTree.Types | Lean.Name → Lean.FVarId → Lean.FVarId → Lean.Elab.FVarAliasInfo | true |
Monotone.seq_pos_lt_seq_of_le_of_lt | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x y : ℕ → α},
Monotone f →
∀ {n : ℕ}, 0 < n → x 0 ≤ y 0 → (∀ k < n, x (k + 1) ≤ f (x k)) → (∀ k < n, f (y k) < y (k + 1)) → x n < y n | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fmod_sub_cancel_left._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (b.fmod a = 0) = (a ∣ b) | false |
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft.inj | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ {e : Lean.Expr} {isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift} {f g h : Mathlib.Tactic.BicategoryLike.Mor₁}
{η : Mathlib.Tactic.BicategoryLike.Mor₂} {e_1 : Lean.Expr} {isoLift?_1 : Option Mathlib.Tactic.BicategoryLike.IsoLift}
{f_1 g_1 h_1 : Mathlib.Tactic.BicategoryLike.Mor₁} {η_1 : Mathlib.Tactic.Bic... | true |
Std.DHashMap.Internal.Raw₀.filterₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} → Std.DHashMap.Internal.Raw₀ α β → ((a : α) → β a → Bool) → Std.DHashMap.Internal.Raw₀ α β | true |
Lean.Elab.Tactic.TacticParsedSnapshot.toSnapshot | Lean.Elab.Term.TermElabM | Lean.Elab.Tactic.TacticParsedSnapshot → Lean.Language.Snapshot | true |
Lean.Lsp.InlayHintKind.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintKind → Sort u} →
(t : Lean.Lsp.InlayHintKind) → motive Lean.Lsp.InlayHintKind.type → motive Lean.Lsp.InlayHintKind.parameter → motive t | false |
Aesop.LocalRuleSet.forwardRulePatternSubstsInLocalDecl | Aesop.RuleSet | Aesop.LocalRuleSet → Lean.LocalDecl → Aesop.BaseM (Array (Aesop.ForwardRule × Aesop.Substitution)) | true |
RingHom.coe_inj | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} ⦃f g : α →+* β⦄, ⇑f = ⇑g → f = g | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceBitVecOfFin.declare_333._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4171913895._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | false |
OmegaCompletePartialOrder.Chain.ext | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} [inst : Preorder α] ⦃f g : OmegaCompletePartialOrder.Chain α⦄, ⇑f = ⇑g → f = g | true |
onePointEquivSphereOfFinrankEq._proof_5 | Mathlib.Topology.Compactification.OnePoint.Sphere | ∀ {ι : Type u_1} {V : Type u_2} [inst : Fintype ι] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V],
Module.finrank ℝ V + 1 = Fintype.card ι → Nonempty ι | false |
Int.strongRec.eq_1 | Mathlib.Data.Int.Basic | ∀ {m : ℤ} {motive : ℤ → Sort u_1} (lt : (n : ℤ) → n < m → motive n)
(ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → motive k) → motive n) (n : ℤ),
Int.strongRec lt ge n =
if hnm : n < m then lt n hnm
else
ge n ⋯
(Int.inductionOn' (motive := fun x => (k : ℤ) → k < x → motive k) n m lt
(fun... | true |
CovBy | Mathlib.Order.Defs.PartialOrder | {α : Type u_2} → [LT α] → α → α → Prop | true |
CategoryTheory.PreOneHypercover.cylinderHomotopy._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (CategoryTheory.PreOneHypercover.cylinder f g).I₀),
CategoryTheory.CategoryStruct.comp
(... | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_6} {B : Type u_3} {C : Type u_8} [inst : CategoryTheory.Category.{u_5, u_6} A]
[inst_1 : CategoryTheory.Category.{u_2, u_3} B] [inst_2 : CategoryTheory.Category.{u_7, u_8} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u_1} {Y : Type u_9}
[inst_3 : CategoryTheory.Cate... | false |
PreAbstractSimplicialComplex.map._proof_2 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] (K : PreAbstractSimplicialComplex α) (f : α → β) {x : Finset β},
x ∈ (fun s => Finset.image f s) '' K.faces →
x.Nonempty ∧ ∀ ⦃b : Finset β⦄, b ≤ x → b.Nonempty → b ∈ (fun s => Finset.image f s) '' K.faces | false |
IntermediateField.intermediateFieldMap_apply_coe | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (e : L ≃ₐ[K] L') (E : IntermediateField K L) (a : ↥E),
↑((IntermediateField.intermediateFieldMap e E) a) = e ↑a | true |
GradedObject.eulerChar_eq_sum_finSet_of_finrankSupport_subset | Mathlib.Algebra.Homology.EulerCharacteristic | ∀ {R : Type u_1} [inst : Ring R] {ι : Type u_2} (c : ComplexShape ι) [inst_1 : c.EulerCharSigns]
(X : CategoryTheory.GradedObject ι (ModuleCat R)) (indices : Finset ι),
GradedObject.finrankSupport X ⊆ ↑indices →
GradedObject.eulerChar c X = ∑ i ∈ indices, ↑(c.χ i) * ↑(Module.finrank R ↑(X i)) | true |
Cardinal.powerlt_mono_left | Mathlib.SetTheory.Cardinal.Basic | ∀ (a : Cardinal.{u_1}), Monotone fun c => a ^< c | true |
Lean.Expr.FindStep.done | Lean.Util.FindExpr | Lean.Expr.FindStep | true |
AlgebraicGeometry.Scheme.irreducibleComponentOpen._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.IrreducibleComponent | ∀ (X : AlgebraicGeometry.Scheme) (Z : Set ↥X) [AlgebraicGeometry.IsNoetherian X],
IsOpen (⋃₀ (irreducibleComponents ↥X \ {Z}))ᶜ | false |
midpoint_eq_midpoint_iff_vsub_eq_vsub | 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 x' y y' : P}, midpoint R x y = midpoint R x' y' ↔ x -ᵥ x' = y' -ᵥ y | true |
CategoryTheory.Limits.MultispanShape.ctorIdx | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_4 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
IsLowerSet.vadd | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α] {s : Set α} {a : α},
IsLowerSet s → IsLowerSet (a +ᵥ s) | true |
PrimeSpectrum.noConfusion | Mathlib.RingTheory.Spectrum.Prime.Defs | {P : Sort u} →
{R : Type u_1} →
{inst : CommSemiring R} →
{t : PrimeSpectrum R} →
{R' : Type u_1} →
{inst' : CommSemiring R'} →
{t' : PrimeSpectrum R'} → R = R' → inst ≍ inst' → t ≍ t' → PrimeSpectrum.noConfusionType P t t' | false |
CategoryTheory.ObjectProperty.shiftClosure_le_iff | Mathlib.CategoryTheory.ObjectProperty.Shift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P Q : CategoryTheory.ObjectProperty C) {A : Type u_2}
[inst_1 : AddMonoid A] [inst_2 : CategoryTheory.HasShift C A] [Q.IsClosedUnderIsomorphisms] [Q.IsStableUnderShift A],
P.shiftClosure A ≤ Q ↔ P ≤ Q | true |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff_eq_sum_rankOne._simp_1_4 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {K : Type u_1} [inst : RCLike K] (r s : ℝ), ↑r * ↑s = ↑(r * s) | false |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.rpcRequest.elim | Lean.Server.ProtocolOverview | {motive : Lean.Server.Overview.MessageOverview✝ → Sort u} →
(t : Lean.Server.Overview.MessageOverview✝¹) →
Lean.Server.Overview.MessageOverview.ctorIdx✝ t = 1 →
((o : Lean.Server.Overview.RpcRequestOverview✝) → motive (Lean.Server.Overview.MessageOverview.rpcRequest✝ o)) →
motive t | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight._proof_12 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight | ∀ {w : ℕ}, 0 ≤ w | false |
CategoryTheory.Limits.HasCokernels.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C],
autoParam (∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasCokernel f)
CategoryTheory.Limits.HasCokernels.has_colimit._autoParam →
CategoryTheory.Limits.HasCokernels C | false |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.PadicInt.mahlerSeries_apply_nat._proof_1_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {m n : ℕ}, m ≤ n → ∀ (i : ℕ), m < i + (n + 1) | false |
Lean.Meta.RefinedDiscrTree.Trie.node._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} →
Array α →
Option Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap ℕ Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap Lean.Meta.RefinedDiscrTree.Key Lean.Meta.RefinedDiscrTree.TrieIndex →
Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α) → Lean.Meta.RefinedDiscrTree.Trie α | false |
Lean.Lsp.WorkspaceSymbolParams.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.WorkspaceSymbolParams → Lean.Lsp.WorkspaceSymbolParams → Sort u | false |
NumberField.mixedEmbedding.fundamentalCone.realSpaceToLogSpace._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x x_1 : NumberField.mixedEmbedding.realSpace K),
(fun w => (x + x_1) ↑w - (↑(↑w).mult * ∑ w', (x + x_1) w') * (↑(Module.finrank ℚ K))⁻¹) =
(fun w => x ↑w - (↑(↑w).mult * ∑ w', x w') * (↑(Module.finrank ℚ K))⁻¹) + fun w =>
x_1 ↑w - (↑(↑w).mult * ∑ w... | false |
Int.lcm_mul_right_right | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.lcm (a * b) = a.natAbs * b.natAbs | true |
qExpansionRingHom | Mathlib.NumberTheory.ModularForms.QExpansion | {Γ : Subgroup (GL (Fin 2) ℝ)} →
(h : ℝ) →
[inst : Γ.HasDetPlusMinusOne] →
0 < h → h ∈ Γ.strictPeriods → (DirectSum ℤ fun k => ModularForm Γ k) →+* PowerSeries ℂ | true |
UInt32.lt_add_one | Init.Data.UInt.Lemmas | ∀ {c : UInt32}, c ≠ -1 → c < c + 1 | true |
PrimeMultiset.prod | Mathlib.Data.PNat.Factors | PrimeMultiset → ℕ+ | true |
String.Slice.Pattern.ToForwardSearcher.mk | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{σ : outParam (String.Slice → Type)} →
((s : String.Slice) → Std.Iter (String.Slice.Pattern.SearchStep s)) → String.Slice.Pattern.ToForwardSearcher pat σ | true |
UpperHalfPlane.num._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | NeZero (1 + 1) | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getEqIffEnumToBitVecEqFor | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.Name → Lean.MetaM Lean.Name | true |
IntermediateField.isSeparable_of_mem_isSeparable | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : IntermediateField F E}
[Algebra.IsSeparable F ↥L] {x : E}, x ∈ L → IsSeparable F x | true |
RootPairing.nsmul_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {ι : 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] (P : RootPairing ι R M N) [CharZero R]
[IsAddTorsionFree M] [P.IsReduced] {n : ℕ} [n.AtLeastTwo] {i : ι}, n • P.root i ∉ Set.range ⇑P.root | true |
Aesop.GoalId.casesOn | Aesop.Tree.Data | {motive : Aesop.GoalId → Sort u} → (t : Aesop.GoalId) → ((toNat : ℕ) → motive { toNat := toNat }) → motive t | false |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.toOplax | Mathlib.CategoryTheory.Bicategory.Monad.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B →
CategoryTheory.OplaxFunctor (CategoryTheory.LocallyDiscrete (CategoryTheory.Discrete PUnit.{1})) B | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.isCongruent.goEq | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENodeMap → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Bool | true |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.fvar a a_1) (Lean.Lsp.RefIdent.fvar b b_1)) →
((x x_2 : ... | false |
Unitization.inrNonUnitalAlgHom._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (r : R)
(m : A), ↑(r • m) = r • ↑m | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_13 | Lean.Meta.LitValues | (motive : Option UInt16 → Sort u_1) →
(__do_lift : Option UInt16) → ((n : UInt16) → motive (some n)) → ((x : Option UInt16) → motive x) → motive __do_lift | false |
_private.Init.Data.Int.Order.0.Int.toNat_sub''.match_1_1 | Init.Data.Int.Order | ∀ (motive : (a b : ℤ) → (∃ n, a = ↑n) → (∃ n, b = ↑n) → 0 ≤ a → 0 ≤ b → Prop) (a b : ℤ) (x : ∃ n, a = ↑n)
(x_1 : ∃ n, b = ↑n) (ha : 0 ≤ a) (hb : 0 ≤ b),
(∀ (w w_1 : ℕ) (ha : 0 ≤ ↑w) (hb : 0 ≤ ↑w_1), motive ↑w ↑w_1 ⋯ ⋯ ha hb) → motive a b x x_1 ha hb | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.PSigma.casesOn._arg_pusher | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | false |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.directSum_iff._simp_1_3 | Mathlib.RingTheory.Flat.Basic | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | false |
Std.DHashMap.Internal.Raw₀.Const.insertMany_nil | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m []) = m | true |
List.dropLast_append_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {b : α} {l₂ : List α}, (l₁ ++ b :: l₂).dropLast = l₁ ++ (b :: l₂).dropLast | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.