name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Set.fintypeInsertOfMem._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {a : α} (s : Set α) [inst : Fintype ↑s], a ∈ s → ∀ (x : α), x ∈ s.toFinset ↔ x ∈ insert a s | false |
UInt16.instLawfulEqOrd | Init.Data.Ord.UInt | Std.LawfulEqOrd UInt16 | true |
Lean.Meta.isPropQuick._unsafe_rec | Lean.Meta.InferType | Lean.Expr → Lean.MetaM Lean.LBool | false |
_private.Mathlib.Algebra.Lie.Basis.0.LieAlgebra.Basis.root_mem_or_mem_neg.match_1_8 | Mathlib.Algebra.Lie.Basis | ∀ {ι : Type u_1} {K : Type u_2} {L : Type u_3} [inst : Fintype ι] [inst_1 : Field K] [inst_2 : CharZero K]
[inst_3 : LieRing L] [inst_4 : LieAlgebra K L] [inst_5 : FiniteDimensional K L] (b : LieAlgebra.Basis ι K L)
(χ : LieModule.Weight K (↥b.cartan) L)
(motive : (∃ n, n ≠ 0 ∧ LieModule.Weight.toLinear K (↥b.car... | false |
MeasureTheory.volume_preserving_funUnique | Mathlib.MeasureTheory.Constructions.Pi | ∀ (α : Type u) (β : Type v) [inst : Unique α] [inst_1 : MeasureTheory.MeasureSpace β],
MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.funUnique α β)) MeasureTheory.volume MeasureTheory.volume | true |
CategoryTheory.Functor.id._proof_1 | Mathlib.CategoryTheory.Functor.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
CategoryTheory.CategoryStruct.id X = CategoryTheory.CategoryStruct.id X | false |
SchwartzMap.instContinuousSMul | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F], ContinuousSMul 𝕜 (SchwartzMap E F) | true |
CochainComplex.mappingConeCompTriangle._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.id X₃) =
CategoryTheory.CategoryStruct.co... | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.elabInductiveViewsPostprocessing.match_1 | Lean.Elab.MutualInductive | (motive : Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool) → Sort u_1) →
(x : Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool)) →
((doc : Lean.TSyntax `Lean.Parser.Command.docComment) → (verso : Bool) → motive (some (doc, verso))) →
((x : Option (Lean.TSyntax `Lean.Parser.Command.doc... | false |
Lean.Meta.Grind.markTheoremInstance | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.GoalM Bool | true |
Int.ceil_ofNat | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsStrictOrderedRing R] (n : ℕ)
[inst_4 : n.AtLeastTwo], ⌈OfNat.ofNat n⌉ = OfNat.ofNat n | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorIdIso | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) →
{ι : Type t} →
(S : C) →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
CategoryTheory.Pseudofunctor.DescentData.pullFu... | true |
ProbabilityTheory.Kernel.iIndepFun.indepFun_prodMk₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8}
{m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ι), AEMeasurabl... | true |
MeasureTheory.Measure.liftLinear | Mathlib.MeasureTheory.Measure.Map | {α : Type u_1} →
{β : Type u_2} →
{mα : MeasurableSpace α} →
[inst : MeasurableSpace β] →
(f : MeasureTheory.OuterMeasure α →ₗ[ENNReal] MeasureTheory.OuterMeasure β) →
(∀ (μ : MeasureTheory.Measure α), inst ≤ (f μ.toOuterMeasure).caratheodory) →
MeasureTheory.Measure α →ₗ[ENNRe... | true |
CategoryTheory.Sum.inr_._proof_2 | Mathlib.CategoryTheory.Sums.Basic | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
{ down := CategoryTheory.CategoryStruct.comp f g } = CategoryTheory.CategoryStruct.comp { down := f } { down := g } | false |
Finpartition.isEquipartition_iff_card_parts_eq_average | Mathlib.Order.Partition.Equipartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s),
P.IsEquipartition ↔ ∀ a ∈ P.parts, a.card = s.card / P.parts.card ∨ a.card = s.card / P.parts.card + 1 | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom._simp_1_1 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} (n : ℕ),
Fintype.card { c // (↑c).support.card = n } = Multiset.count n σ.cycleType | false |
Std.DHashMap.Raw.contains_insert | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a k : α} {v : β k}, (m.insert k v).contains a = (k == a || m.contains a) | true |
Lean.Elab.Command.instInhabitedCommandElabM | Lean.Elab.Command | {α : Type} → Inhabited (Lean.Elab.Command.CommandElabM α) | true |
PresheafOfModules.Hom.naturality_assoc | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (self : M₁.Hom M₂) {X Y : Cᵒᵖ} (f : X ⟶ Y) {Z : ModuleCat ↑(R.obj X)}
(h : (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M₂.obj Y) ⟶ Z),
CategoryTheory.CategoryStruct.c... | true |
AddSubgroup.toAddSubmonoid_zmultiples | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (g : G),
(AddSubgroup.zmultiples g).toAddSubmonoid = AddSubmonoid.multiples g ⊔ AddSubmonoid.multiples (-g) | true |
_private.Mathlib.Order.UpperLower.Basic.0.isUpperSet_iff_forall_lt._simp_1_3 | Mathlib.Order.UpperLower.Basic | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | false |
CategoryTheory.CountableAB4.recOn | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasCountableCoproducts C] →
{motive : CategoryTheory.CountableAB4 C → Sort u_1} →
(t : CategoryTheory.CountableAB4 C) →
((ofShape :
∀ (α : Type) [inst_2 : Countable α],
... | false |
Std.DHashMap.Raw.Const.contains_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF →
(Std.DHashMap.Raw.Const.alter m k f).contains k' =
if (k == k') = true then (f (Std.DHashMap.Raw.Const.get? m k)).isSom... | true |
Primrec.option_orElse | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ fun x1 x2 => x1 <|> x2 | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformContinuous.image_hausdorff._simp_1_6 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (f '' s ⊆ t) = (s ⊆ f ⁻¹' t) | false |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Ico_filter_pow_dvd_eq._simp_1_2 | Mathlib.Data.Nat.Factorization.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | false |
Finset.powerset._proof_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} (s : Finset α), ∀ _t ∈ s.val.powerset, _t.Nodup | false |
CompleteOrthogonalIdempotents.toOrthogonalIdempotents | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} [inst : Semiring R] {I : Type u_3} [inst_1 : Fintype I] {e : I → R},
CompleteOrthogonalIdempotents e → OrthogonalIdempotents e | true |
Std.DHashMap.Raw.WF.below.casesOn | Std.Data.DHashMap.Raw | ∀ {α : Type u}
{motive : {β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → (a : Std.DHashMap.Raw α β) → a.WF → Prop}
{motive_1 :
{β : α → Type v} →
{inst : BEq α} →
{inst_1 : Hashable α} → {a : Std.DHashMap.Raw α β} → (t : a.WF) → Std.DHashMap.Raw.WF.below t → Prop}
{β : α → Type v} {i... | false |
Set.Iic.orderBot._proof_2 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderBot α] (x : ↑(Set.Iic a)), ⟨⊥, ⋯⟩ ≤ x | false |
MvPolynomial.join₂_comp_map | Mathlib.Algebra.MvPolynomial.Monad | ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
(f : R →+* MvPolynomial σ S), MvPolynomial.join₂.comp (MvPolynomial.map f) = MvPolynomial.bind₂ f | true |
ZSpan.ceil.congr_simp | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (m m_1 : E), m = m_1 → ZSpan.ceil b m = ZSpan.ceil b m_1 | true |
MulSemiringActionHom.mk.inj | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} {inst : Monoid M} {N : Type u_2} {inst_1 : Monoid N} {φ : M →* N} {R : Type u_10} {inst_2 : Semiring R}
{inst_3 : MulSemiringAction M R} {S : Type u_12} {inst_4 : Semiring S} {inst_5 : MulSemiringAction N S}
{toDistribMulActionHom : R →ₑ+[φ] S} {map_one' : toDistribMulActionHom.toFun 1 = 1}
{map_... | true |
AlgebraicTopology.NormalizedMooreComplex.objX.match_1 | Mathlib.AlgebraicTopology.MooreComplex | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | false |
SSet.Truncated.ev01₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2}
(φ : V.obj (Opposite.op { obj := SimplexCategory.mk 2, property := SSet.Truncated.ι0₂._proof_3 })),
V.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op
(V.map SSet.Truncated.δ2₂.op φ) =
V.map SSet.Truncated.ι0₂.op φ | false |
Std.DTreeMap.Internal.Cell._sizeOf_1 | Std.Data.DTreeMap.Internal.Cell | {α : Type u} →
{inst : Ord α} →
{β : α → Type v} → {k : α → Ordering} → [SizeOf α] → [(a : α) → SizeOf (β a)] → Std.DTreeMap.Internal.Cell α β k → ℕ | false |
CategoryTheory.Functor.op | Mathlib.CategoryTheory.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → CategoryTheory.Functor Cᵒᵖ Dᵒᵖ | true |
CoalgCat.ofComon._proof_2 | Mathlib.Algebra.Category.CoalgCat.ComonEquivalence | ∀ (R : Type u_1) [inst : CommRing R] {X Y Z : CategoryTheory.Comon (ModuleCat R)} (f : X ⟶ Y) (g : Y ⟶ Z),
{
toCoalgHom' :=
let __src := ModuleCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g).hom;
{ toLinearMap := __src, counit_comp := ⋯, map_comp_comul := ⋯ } } =
CategoryTheory.Category... | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify.0.Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr.of.binaryReflection._unsafe_rec | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify | Lean.Expr →
Lean.Expr →
Std.Tactic.BVDecide.BVBinOp →
Lean.Name →
Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.LemmaM (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) | false |
NNRat.den_ne_zero | Mathlib.Data.NNRat.Defs | ∀ (q : ℚ≥0), q.den ≠ 0 | true |
Equiv.Perm.apply_zpow_apply_eq_iff._simp_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} (f : Equiv.Perm α) (n : ℤ) {x : α}, (f ((f ^ n) x) = (f ^ n) x) = (f x = x) | false |
WittVector.ghostMap_apply | Mathlib.RingTheory.WittVector.Basic | ∀ {p : ℕ} {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (x : WittVector p R) (n : ℕ),
WittVector.ghostMap x n = (WittVector.ghostComponent n) x | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.mk.noConfusion | Lean.Meta.Sym.Pattern | {P : Sort u} →
{eAssignment : Array (Option Lean.Expr)} →
{uAssignment : Array (Option Lean.Level)} →
{ePending : Array (Lean.Expr × Lean.Expr)} →
{uPending : Array (Lean.Level × Lean.Level)} →
{iPending : Array (Lean.Expr × Lean.Expr)} →
{tPending : Array ℕ} →
{u... | false |
coe_nndist | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), ↑(nndist x y) = dist x y | true |
contMDiffAt_of_subsingleton | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : 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] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | true |
Dyadic.toRat_lt_toRat_iff | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, x.toRat < y.toRat ↔ x < y | true |
Equiv.sigmaULiftPLiftEquivSubtype | Mathlib.Logic.Equiv.Defs | {α : Type v} → (P : α → Prop) → (i : α) × ULift.{u_1, 0} (PLift (P i)) ≃ Subtype P | true |
Std.Iterators.Types.RepeatIterator.mk._flat_ctor | Std.Data.Iterators.Producers.Repeat | {α : Type u} → {f : α → α} → α → Std.Iterators.Types.RepeatIterator α f | false |
String.Pos.prev_ne_endPos._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {h : p ≠ s.startPos}, (p.prev h = s.endPos) = False | false |
NonUnitalAlgebra.comap_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] [inst_5 : IsScalarTower R A A]
[inst_6 : SMulCommClass R A A] [inst_7 : IsScalarTower R B B] [inst_8 : SMulCommClass R B B] (f : ... | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.Mathlib.Meta.Positivity.evalNNRealRpow._proof_2 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (α : Q(Type)) (x : Q(PartialOrder «$α»)) (__defeqres : PLift («$x» =Q NNReal.instPartialOrder)),
«$x» =Q NNReal.instPartialOrder | false |
Lean.Meta.UnificationHint.pattern | Lean.Meta.UnificationHint | Lean.Meta.UnificationHint → Lean.Meta.UnificationConstraint | true |
OnePoint.coe_preimage_infty | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1}, OnePoint.some ⁻¹' {OnePoint.infty} = ∅ | true |
SSet.skeleton_obj_eq_top | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ (X : SSet) {d n : ℕ}, d < n → (X.skeleton n).obj (Opposite.op (SimplexCategory.mk d)) = ⊤ | true |
CategoryTheory.Localization.Construction.whiskerLeft_natTransExtension | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C} {D : Type uD}
[inst_1 : CategoryTheory.Category.{uD', uD} D] {F G : CategoryTheory.Functor W.Localization D}
(τ : W.Q.comp F ⟶ W.Q.comp G), W.Q.whiskerLeft (CategoryTheory.Localization.Construction.natTransExtension... | true |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_44 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | false |
QuaternionAlgebra.Basis.j_compHom | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {c₁ c₂ c₃ : R} (q : QuaternionAlgebra.Basis A c₁ c₂ c₃) (F : A →ₐ[R] B),
(q.compHom F).j = F q.j | true |
LinearMap.compDer._proof_4 | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {N : Type u_2}
[inst_6 : AddCommMonoid N] [inst_7 : Module A N] [inst_8 : Module R N] [inst_9 : IsScalarTower R A M]
[inst_... | false |
Set.pi_def | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {π : α → Type u_12} (i : Set α) (s : (a : α) → Set (π a)), i.pi s = ⋂ a ∈ i, Function.eval a ⁻¹' s a | true |
Lean.JsonNumber.exponent | Lean.Data.Json.Basic | Lean.JsonNumber → ℕ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_eq_some_iff_exists_compare_eq_eq_and_mem_toList._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 |
List.Vector.insertIdx._proof_2 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (i : Fin (n + 1)) (v : List.Vector α n), ((↑v).insertIdx (↑i) a).length = n + 1 | false |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.Gamma0._simp_3 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) | false |
Lean.Meta.Rewrites.SideConditions.noConfusionType | Lean.Meta.Tactic.Rewrites | Sort v✝ → Lean.Meta.Rewrites.SideConditions → Lean.Meta.Rewrites.SideConditions → Sort v✝ | true |
ringKrullDim_eq_zero_of_field | Mathlib.RingTheory.KrullDimension.Field | ∀ (F : Type u_1) [inst : Field F], ringKrullDim F = 0 | true |
CategoryTheory.Limits.HasImageMap.has_image_map | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {f g : CategoryTheory.Arrow C}
{inst_1 : CategoryTheory.Limits.HasImage f.hom} {inst_2 : CategoryTheory.Limits.HasImage g.hom} {sq : f ⟶ g}
[self : CategoryTheory.Limits.HasImageMap sq], Nonempty (CategoryTheory.Limits.ImageMap sq) | true |
UInt16.neg_sub | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, -(a - b) = b - a | true |
Lean.DeclarationRange.charUtf16 | Lean.Data.DeclarationRange | Lean.DeclarationRange → ℕ | true |
SimpleGraph.bot_adj._simp_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (v w : V), ⊥.Adj v w = False | false |
_private.Init.Data.Vector.Lemmas.0.Vector.append_eq_append_iff._proof_7 | Init.Data.Vector.Lemmas | ∀ {n m k l : ℕ}, k + l = n + m → ¬n ≤ k → ¬n - k + m = l → False | false |
CategoryTheory.Pretriangulated.Triangle.mk' | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
(obj₁ obj₂ obj₃ : C) →
(obj₁ ⟶ obj₂) →
(obj₂ ⟶ obj₃) →
(obj₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj obj₁) → CategoryTheory.Pretriangulated.Triangle C | true |
instBoundedSpaceOrderDual | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} [inst : Bornology α] [BoundedSpace α], BoundedSpace αᵒᵈ | true |
DirectedOn.notMem_of_lt_csInf | Mathlib.Order.ConditionallyCompletePartialOrder.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderInf α] {x : α} {s : Set α},
DirectedOn (fun x1 x2 => x2 ≤ x1) s → x < sInf s → BddBelow s → x ∉ s | true |
Module.Basis.mem_span_iff_repr_mem | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {ι : Type u_1} (R : Type u_3) {M : Type u_5} {S : Type u_7} [inst : CommRing R] [IsDomain R] [inst_2 : Ring S]
[Nontrivial S] [inst_4 : AddCommGroup M] [inst_5 : Algebra R S] [inst_6 : Module S M] [inst_7 : Module R M]
[IsScalarTower R S M] [Module.IsTorsionFree R S] (b : Module.Basis ι S M) (m : M),
m ∈ Submod... | true |
Equiv.nonAssocRing._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonAssocRing β], e (e.symm 0) = 0 | false |
Mathlib.Linter.TextBased.instBEqErrorFormat.beq | Mathlib.Tactic.Linter.TextBased | Mathlib.Linter.TextBased.ErrorFormat → Mathlib.Linter.TextBased.ErrorFormat → Bool | true |
AlgebraicGeometry.Scheme.Cover.Over.recOn | Mathlib.AlgebraicGeometry.Cover.Over | {S : AlgebraicGeometry.Scheme} →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[inst : P.IsStableUnderBaseChange] →
[inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X : AlgebraicGeometry.Scheme} →
[inst_2 : X.Over S] →
{𝒰 : AlgebraicGeo... | false |
Lean.Lsp.ReferenceContext.includeDeclaration | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → Bool | true |
WeierstrassCurve.VariableChange.mapHom | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | {R : Type u} →
[inst : CommRing R] →
{A : Type v} →
[inst_1 : CommRing A] → (R →+* A) → WeierstrassCurve.VariableChange R →* WeierstrassCurve.VariableChange A | true |
Lean.Elab.Term.Op.elabUnOp._regBuiltin.Lean.Elab.Term.Op.elabUnOp_1 | Lean.Elab.Extra | IO Unit | false |
ContinuousLinearEquiv.continuousMultilinearMapCongrLeft_apply | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {E₁ : ι → Type u_4} {F : Type u_5} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : (i : ι) → TopologicalSpace (E₁ i)]
[inst_5 : (i : ι) → AddCommGroup (E₁ ... | true |
Std.Tactic.BVDecide.Normalize.BitVec.ite_else_not_ite | Std.Tactic.BVDecide.Normalize.Bool | ∀ {w : ℕ} (cond : Bool) {a b c : BitVec w}, (bif cond then a else ~~~bif cond then b else c) = bif cond then a else ~~~c | true |
Lean.Order.instCCPOEIOOfNonempty._proof_3 | Init.Internal.Order.Basic | ∀ {ε α : Type} [inst : Nonempty ε] {x : EIO ε α}, Lean.Order.instCCPOEIOOfNonempty._aux_1 x x | false |
Filter.map_mul_left_nhdsGT | Mathlib.Topology.Algebra.Group.Basic | ∀ {H : Type x} [inst : TopologicalSpace H] [inst_1 : CommGroup H] [inst_2 : PartialOrder H] [IsOrderedMonoid H]
[ContinuousMul H] {c a : H},
Filter.map (fun x => c * x) (nhdsWithin a (Set.Ioi a)) = nhdsWithin (c * a) (Set.Ioi (c * a)) | true |
ContinuousAddMonoidHom.toContinuousAddMonoidHom._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {B : Type u_2} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] {F : Type u_3} [inst_4 : FunLike F A B] [inst_5 : AddMonoidHomClass F A B]
[ContinuousMapClass F A B] (f : F), Continuous (↑↑f).toFun | false |
Std.DTreeMap.le_maxKeyD_of_contains | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxKeyD fallback)).isLE = true | true |
Localization.mulEquivOfQuotient_mk' | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
{f : S.LocalizationMap N} (x : M) (y : ↥S),
(Localization.mulEquivOfQuotient f) ((Localization.monoidOf S).mk' x y) = f.mk' x y | true |
Cardinal.natCast_mul_le_natCast_mul._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (↑n * a ≤ ↑n * b) = (a ≤ b) | false |
_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.isCursorOnWhitespace | Lean.Server.Completion.SyntheticCompletion | Lean.FileMap → String.Pos.Raw → Bool | true |
Lean.Core.State.mk | Lean.CoreM | Lean.Environment →
Lean.MacroScope →
Lean.NameGenerator →
Lean.DeclNameGenerator →
Lean.TraceState →
Lean.Core.Cache →
Lean.MessageLog →
Lean.Elab.InfoState → Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree) → Lean.Core.State | true |
Set.Finite.isCountablyCompact_sUnion | Mathlib.Topology.Compactness.CountablyCompact | ∀ {E : Type u_2} [inst : TopologicalSpace E] {S : Set (Set E)},
S.Finite → (∀ s ∈ S, IsCountablyCompact s) → IsCountablyCompact (⋃₀ S) | true |
minpoly.natDegree_pos | Mathlib.FieldTheory.Minpoly.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} [Nontrivial B],
IsIntegral A x → 0 < (minpoly A x).natDegree | true |
LatticeHom.toSupHom | Mathlib.Order.Hom.Lattice | {α : Type u_6} → {β : Type u_7} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom α β → SupHom α β | true |
_private.Mathlib.CategoryTheory.Triangulated.SpectralObject.0.CategoryTheory.Triangulated.SpectralObject._proof_7 | Mathlib.CategoryTheory.Triangulated.SpectralObject | 0 ≤ 2 | false |
MvPolynomial.isAlgebraic_of_mem_vars_of_forall_totalDegree_le | Mathlib.FieldTheory.SeparablyGenerated | ∀ {k : Type u_1} {K : Type u_2} {ι : Type u_3} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {a : ι → K}
{F : MvPolynomial ι k},
(∀ (F' : MvPolynomial ι k), F' ≠ 0 → (MvPolynomial.aeval a) F' = 0 → F.totalDegree ≤ F'.totalDegree) →
(MvPolynomial.aeval a) F = 0 → ∀ i ∈ F.vars, IsAlgebraic (↥(Algebra... | true |
DirectSum.addEquivProdDirectSum | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{α : Option ι → Type w} →
[inst : (i : Option ι) → AddCommMonoid (α i)] →
(DirectSum (Option ι) fun i => α i) ≃+ α none × DirectSum ι fun i => α (some i) | true |
AddAction.stabilizer_vadd_eq_left | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : AddAction G β]
[inst_3 : VAdd α β] [VAddAssocClass G α β] (a : α) (b : β),
(Function.Injective fun x => x +ᵥ b) → AddAction.stabilizer G (a +ᵥ b) = AddAction.stabilizer G a | true |
Lean.Grind.IntModule.OfNatModule.r_rfl | Init.Grind.Module.Envelope | ∀ {α : Type u} [inst : Lean.Grind.NatModule α] (a : α × α), Lean.Grind.IntModule.OfNatModule.r α a a | true |
List.pmap_eq_pmapImpl | Init.Data.List.Attach | @List.pmap = @List.pmapImpl | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.