name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Valuation.IsEquiv.orderMonoidIso._proof_5 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_2} {Γ₀ : Type u_3} {Γ'₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀]
[inst_1 : LinearOrderedCommGroupWithZero Γ'₀] [inst_2 : Ring R] {v : Valuation R Γ₀} {w : Valuation R Γ'₀}
(h : v.IsEquiv w) (x y : MonoidWithZeroHom.ValueGroup₀ v),
h.valueGroup₀Fun (x * y) = h.valueGroup₀Fun x * h.value... | false |
IsUpperSet.Ici_subset | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, IsUpperSet s → ∀ ⦃a : α⦄, a ∈ s → Set.Ici a ⊆ s | true |
Nat.Partrec.Code.ctorElim | Mathlib.Computability.PartrecCode | {motive : Nat.Partrec.Code → Sort u} →
(ctorIdx : ℕ) → (t : Nat.Partrec.Code) → ctorIdx = t.ctorIdx → Nat.Partrec.Code.ctorElimType ctorIdx → motive t | false |
hasSum_unique | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Unique β] (f : β → α)
(L : optParam (SummationFilter β) (SummationFilter.unconditional β)) [L.LeAtTop], HasSum f (f default) L | true |
Int64.add_left_neg | Init.Data.SInt.Lemmas | ∀ (a : Int64), -a + a = 0 | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.N._default | Std.Time.Format.Basic | Option Std.Time.Nanosecond.Offset | false |
_private.Mathlib.RingTheory.Flat.Tensor.0.Module.Flat.iff_rTensor_injective'._simp_1_5 | Mathlib.RingTheory.Flat.Tensor | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | false |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_integral_remainder_aux._proof_1_8 | Mathlib.Analysis.Calculus.Taylor | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] (a b c d : F), b = c → a = -d → a - b = -c - d | false |
Array.findIdx?_take | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {p : α → Bool},
Array.findIdx? p (xs.take i) = (Array.findIdx? p xs).bind (Option.guard fun j => decide (j < i)) | true |
_private.Mathlib.FieldTheory.KummerExtension.0.autEquivRootsOfUnity_smul._simp_1_6 | Mathlib.FieldTheory.KummerExtension | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | false |
Lean.Meta.Grind.addSplitCandidate | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SplitInfo → Lean.Meta.Grind.GoalM Unit | true |
MeasureTheory.vaddInvariantMeasure_tfae | Mathlib.MeasureTheory.Group.Action | ∀ (G : Type u) {α : Type w} {m : MeasurableSpace α} [inst : AddGroup G] [inst_1 : AddAction G α]
(μ : MeasureTheory.Measure α) [MeasurableConstVAdd G α],
[MeasureTheory.VAddInvariantMeasure G α μ, ∀ (c : G) (s : Set α), MeasurableSet s → μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s,
∀ (c : G) (s : Set α), MeasurableSet ... | true |
ContinuousEval.continuous_eval | Mathlib.Topology.Hom.ContinuousEval | ∀ {F : Type u_1} {X : outParam (Type u_2)} {Y : outParam (Type u_3)} {inst : FunLike F X Y}
{inst_1 : TopologicalSpace F} {inst_2 : TopologicalSpace X} {inst_3 : TopologicalSpace Y}
[self : ContinuousEval F X Y], Continuous fun fx => fx.1 fx.2 | true |
Pi.instSMulPosStrictMono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {ι : Type u_3} {β : ι → Type u_4} [inst : Zero α] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : PartialOrder α] [inst_3 : (i : ι) → PartialOrder (β i)] [inst_4 : (i : ι) → SMulWithZero α (β i)]
[∀ (i : ι), SMulPosStrictMono α (β i)], SMulPosStrictMono α ((i : ι) → β i) | true |
LiouvilleNumber.partialSum_eq_rat | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleNumber | ∀ {m : ℕ}, 0 < m → ∀ (k : ℕ), ∃ p, LiouvilleNumber.partialSum (↑m) k = ↑p / ↑(m ^ k.factorial) | true |
CategoryTheory.GlueData.gluedIso._proof_1 | 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')
[CategoryTheory.Limits.HasMulticoequalizer D.diagram] [CategoryTheory.Limits.PreservesColimit D.diagram.multispan F],
Ca... | false |
Lean.Meta.Grind.EMatch.Cnstr.continue.injEq | Lean.Meta.Tactic.Grind.EMatch | ∀ (pat pat_1 : Lean.Expr),
(Lean.Meta.Grind.EMatch.Cnstr.continue pat = Lean.Meta.Grind.EMatch.Cnstr.continue pat_1) = (pat = pat_1) | true |
CochainComplex.shortComplexTruncLEX₃ToTruncGE | Mathlib.Algebra.Homology.Embedding.CochainComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
(K : CochainComplex C ℤ) → (n₀ n₁ : ℤ) → n₀ + 1 = n₁ → ((K.shortComplexTruncLE n₀).X₃ ⟶ K.truncGE n₁) | true |
CategoryTheory.Limits.BiconeMorphism.mk.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{F : J → C} →
{A B : CategoryTheory.Limits.Bicone F} →
{P : Sort u} →
{hom : A.pt ⟶ B.pt} →
{wπ :
... | false |
range_mem_nhds_isInteriorPoint | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : 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] {x : M},
I.IsInteriorPoint x → Set.ra... | true |
CategoryTheory.Sieve.overEquiv_bot | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y : CategoryTheory.Over X),
(CategoryTheory.Sieve.overEquiv Y) ⊥ = ⊥ | true |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₃'_tensorHom | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : CategoryTheory.GradedObject I C}
[inst_3 : X₁.HasTensor X₂] [inst_4 : (CategoryTheory.GradedObject.Monoidal.tensorObj X₁ X₂).HasTensor X₃]
[inst_5 : ... | true |
Module.Flat.dfinsupp_iff | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} [inst : CommSemiring R] {ι : Type v} {M : ι → Type w} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)], Module.Flat R (Π₀ (i : ι), M i) ↔ ∀ (i : ι), Module.Flat R (M i) | true |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Array.0.Std.Iterators.Types.ArrayIterator.instIterator.match_1.splitter | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | {m : Type u_1 → Type u_2} →
{α : Type u_1} →
(motive : Std.IterStep (Std.IterM m α) α → Sort u_3) →
(x : Std.IterStep (Std.IterM m α) α) →
((it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out)) →
((it : Std.IterM m α) → motive (Std.IterStep.skip it)) → (Unit → motive Std... | true |
Submodule.iSup_eq_range_dfinsupp_lsum | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {N : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N]
[inst_3 : DecidableEq ι] (p : ι → Submodule R N), iSup p = ((DFinsupp.lsum ℕ) fun i => (p i).subtype).range | true |
ArchimedeanClass.instAddCommMagma | Mathlib.Algebra.Order.Ring.Archimedean | {R : Type u_1} →
[inst : LinearOrder R] → [inst_1 : CommRing R] → [inst_2 : IsStrictOrderedRing R] → AddCommMagma (ArchimedeanClass R) | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.div_spanSingleton._simp_1_2 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.elabCommand.go._unsafe_rec | Lean.Elab.Command | Lean.Syntax → Lean.Elab.Command.CommandElabM Unit | false |
norm_add_sq_real | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {F : Type u_3} [inst : SeminormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * inner ℝ x y + ‖y‖ ^ 2 | true |
Std.Internal.List.maxKey?_alterKey_eq_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
[inst_4 : Std.LawfulEqOrd α] {k : α} {f : Option (β k) → Option (β k)} {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
(Std.Internal.List.maxKey? (Std.Internal.List.alterKey k f l) = som... | true |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.sigmaCongrRight._proof_1 | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_2} {β₁ : α → Type u_1} {β₂ : α → Type u_3} (F : (a : α) → β₁ a ≃ β₂ a),
Function.LeftInverse (fun a => ⟨a.fst, (F a.fst).symm a.snd⟩) fun a => ⟨a.fst, (F a.fst) a.snd⟩ | false |
CategoryTheory.Codiscrete.natIsoFunctor_hom_app | Mathlib.CategoryTheory.CodiscreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w}
{F : CategoryTheory.Functor C (CategoryTheory.Codiscrete A)} (X : C),
CategoryTheory.Codiscrete.natIsoFunctor.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X) | true |
Subfield.relrank_eq_one_of_le | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B : Subfield E}, B ≤ A → A.relrank B = 1 | true |
CategoryTheory.Functor.FullyFaithful._sizeOf_1 | Mathlib.CategoryTheory.Functor.FullyFaithful | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} → [SizeOf C] → [SizeOf D] → F.FullyFaithful → ℕ | false |
Finset.instNonemptyElemCoeInsert | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (i : α) (s : Finset α), Nonempty ↑↑(insert i s) | true |
AlgebraicGeometry.IsLocalAtSource.of_isOpenImmersion | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsZariskiLocalAtSource P]
{X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [P.ContainsIdentities] [AlgebraicGeometry.IsOpenImmersion f], P f | true |
Polynomial.irreducible_iff_roots_eq_zero_of_degree_le_three | Mathlib.Algebra.Polynomial.SpecificDegree | ∀ {K : Type u_1} [inst : Field K] {p : Polynomial K}, 2 ≤ p.natDegree → p.natDegree ≤ 3 → (Irreducible p ↔ p.roots = 0) | true |
AdjoinRoot.modByMonicHom.congr_simp | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {g : Polynomial R} (hg : g.Monic),
AdjoinRoot.modByMonicHom hg = AdjoinRoot.modByMonicHom hg | true |
AddSubgroup.fg_iff_mul_fg | Mathlib.GroupTheory.Finiteness | ∀ {H : Type u_4} [inst : AddGroup H] (P : AddSubgroup H), P.FG ↔ (AddSubgroup.toSubgroup P).FG | true |
IsPreconnected.biUnion_of_chain | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder β] [inst_2 : SuccOrder β]
[IsSuccArchimedean β] {s : β → Set α} {t : Set β},
t.OrdConnected →
(∀ n ∈ t, IsPreconnected (s n)) →
(∀ n ∈ t, Order.succ n ∈ t → (s n ∩ s (Order.succ n)).Nonempty) → IsPreconnected (⋃ n ∈ t, s n) | true |
Mathlib.Tactic.ITauto.AndKind.rec | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.AndKind → Sort u} →
motive Mathlib.Tactic.ITauto.AndKind.and →
motive Mathlib.Tactic.ITauto.AndKind.iff →
motive Mathlib.Tactic.ITauto.AndKind.eq → (t : Mathlib.Tactic.ITauto.AndKind) → motive t | false |
Std.Time.PlainDateTime.subMonthsRollOver | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Month.Offset → Std.Time.PlainDateTime | true |
CategoryTheory.Functor.isoSum | Mathlib.CategoryTheory.Sums.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor (A ⊕ B) C) →
F ≅ ((CategoryTheory.Sum.inl_ A B... | true |
BoolRing.Hom.rec | Mathlib.Algebra.Category.BoolRing | {R : BoolRing} →
{S : BoolRing} →
{motive : R.Hom S → Sort u} → ((hom' : ↑R →+* ↑S) → motive { hom' := hom' }) → (t : R.Hom S) → motive t | false |
Nat.disjointedRec | Mathlib.Algebra.Order.Disjointed | {α : Type u_1} →
[inst : GeneralizedBooleanAlgebra α] →
{f : ℕ → α} → {p : α → Sort u_3} → (⦃t : α⦄ → ⦃i : ℕ⦄ → p t → p (t \ f i)) → ⦃n : ℕ⦄ → p (f n) → p (disjointed f n) | true |
Std.ExtDHashMap.Const.insertMany_nil | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], Std.ExtDHashMap.Const.insertMany m [] = m | true |
ProperlyDiscontinuousVAdd.mk._flat_ctor | Mathlib.Topology.Algebra.ConstMulAction | ∀ {Γ : Type u_4} {T : Type u_5} [inst : TopologicalSpace T] [inst_1 : VAdd Γ T],
(∀ {K L : Set T}, IsCompact K → IsCompact L → {γ | ((fun x => γ +ᵥ x) '' K ∩ L).Nonempty}.Finite) →
ProperlyDiscontinuousVAdd Γ T | false |
String.posGT_eq_next | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} {h : p < s.rawEndPos} (h' : String.Pos.Raw.IsValid s p),
s.posGT p h = (s.pos p h').next ⋯ | true |
WithZero.unzero_coe | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} {x : α} (hx : ↑x ≠ 0), WithZero.unzero hx = x | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.List.takeWhile_eq_filter_of_pairwise | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {p : α → Bool} {l : List α},
List.Pairwise (fun a b => p a = false → p b = false) l → List.takeWhile p l = List.filter p l | true |
Nat.toUInt32 | Init.Data.UInt.BasicAux | ℕ → UInt32 | true |
DFinsupp.sum | Mathlib.Data.DFinsupp.BigOperators | {ι : Type u} →
{γ : Type w} →
{β : ι → Type v} →
[DecidableEq ι] →
[inst : (i : ι) → Zero (β i)] →
[(i : ι) → (x : β i) → Decidable (x ≠ 0)] → [AddCommMonoid γ] → (Π₀ (i : ι), β i) → ((i : ι) → β i → γ) → γ | true |
FiberPrebundle.noConfusion | Mathlib.Topology.FiberBundle.Basic | {P : Sort u} →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_5} →
{inst : TopologicalSpace B} →
{inst_1 : TopologicalSpace F} →
{inst_2 : (x : B) → TopologicalSpace (E x)} →
{t : FiberPrebundle F E} →
{B' : Type u_2} →
{F' : T... | false |
Mathlib.Tactic.GCongr.imp_right_mono | Mathlib.Tactic.GCongr.CoreAttrs | ∀ {a b c : Prop}, (a → b → c) → (a → b) → a → c | true |
CategoryTheory.preadditiveCoyonedaObj_map | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (X : C) {X_1 Y : C}
(f : X_1 ⟶ Y),
(CategoryTheory.preadditiveCoyonedaObj X).map f =
ModuleCat.ofHom { toFun := fun g => CategoryTheory.CategoryStruct.comp g f, map_add' := ⋯, map_smul' := ⋯ } | true |
ChartedSpaceCore.mk.sizeOf_spec | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u_5} [inst : TopologicalSpace H] {M : Type u_6} [inst_1 : SizeOf H] [inst_2 : SizeOf M]
(atlas : Set (PartialEquiv M H)) (chartAt : M → PartialEquiv M H)
(mem_chart_source : ∀ (x : M), x ∈ (chartAt x).source) (chart_mem_atlas : ∀ (x : M), chartAt x ∈ atlas)
(open_source : ∀ (e e' : PartialEquiv M H), ... | true |
LieModuleHom.instSMul | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | true |
Subring.add_mem | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) {x y : R}, x ∈ s → y ∈ s → x + y ∈ s | true |
Polynomial.natDegree_zero | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R], Polynomial.natDegree 0 = 0 | true |
Filter.pi_principal | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [Finite ι] (s : (i : ι) → Set (α i)),
(Filter.pi fun i => Filter.principal (s i)) = Filter.principal (Set.univ.pi s) | true |
RelEmbedding.natLT._proof_1 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} [IsStrictOrder α r], Std.Asymm r | false |
Std.max_eq_or | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : Max α] [Std.MaxEqOr α] {a b : α}, a ⊔ b = a ∨ a ⊔ b = b | true |
CategoryTheory.Bicategory.lanLiftUnit_desc | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
[inst_1 : CategoryTheory.Bicategory.HasLeftKanLift f g] (s : CategoryTheory.Bicategory.LeftLift f g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.lanLiftUnit f g)
(CategoryTheory.Bicategory.whiskerRight (... | true |
Std.DTreeMap.Internal.Impl.Const.isEmpty_alter!_eq_isEmpty_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).isEmpty =
((Std.DTreeMap.Internal.Impl.erase! k t).isEmpty && (f (Std.DTreeMap.Internal.Impl.Const... | true |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findInfoTree?.match_7 | Lean.Server.CodeActions.Provider | (motive : Option (Lean.Elab.ContextInfo × Lean.Elab.InfoTree) → Sort u_1) →
(x : Option (Lean.Elab.ContextInfo × Lean.Elab.InfoTree)) →
(Unit → motive none) → ((a : Lean.Elab.ContextInfo × Lean.Elab.InfoTree) → motive (some a)) → motive x | false |
CompactlySupportedContinuousMapClass.instCoeTCCompactlySupportedContinuousMap._proof_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Zero β]
[inst_2 : TopologicalSpace β] [inst_3 : FunLike F α β] [CompactlySupportedContinuousMapClass F α β] (f : F),
Continuous ⇑f | false |
Std.Rio.Internal.isPlausibleIndirectOutput_iter_iff | Init.Data.Range.Polymorphic.Iterators | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.Least? α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[Std.PRange.LawfulUpwardEnumerableLeast? α] {r : Std.Rio α} {a : α},
(Std.Rio.Internal.iter r).IsPlausibleIndi... | true |
AddGroupCone.mem_nonneg._simp_1 | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : AddCommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedAddMonoid H] {a : H},
(a ∈ AddGroupCone.nonneg H) = (0 ≤ a) | false |
wrapped._@.Mathlib.Analysis.Calculus.TangentCone.Defs.1253705803._hygCtx._hyg.2 | Mathlib.Analysis.Calculus.TangentCone.Defs | Subtype (Eq definition✝) | false |
List.traverse_eq_map_id | Mathlib.Control.Traversable.Instances | ∀ {α β : Type u_1} (f : α → β) (x : List α), List.traverse (pure ∘ f) x = pure (f <$> x) | true |
RootPairing.IsBalanced.recOn | Mathlib.LinearAlgebra.RootSystem.BaseChange | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : AddCommGroup M] →
[inst_1 : AddCommGroup N] →
[inst_2 : CommRing R] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
{P : RootPairing ι R M N} →
... | false |
Order.length_le_height | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {p : LTSeries α} {x : α}, RelSeries.last p ≤ x → ↑p.length ≤ Order.height x | true |
Std.DTreeMap.Internal.Impl.Const.getD_erase_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.Const.getD (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl k fallback = fallback | true |
CategoryTheory.Pseudofunctor.CoGrothendieck.forget_obj | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat) (X : F.CoGrothendieck),
(CategoryTheory.Pseudofunctor.CoGrothendieck.forget F).obj X = X.base | true |
_private.Lean.PrettyPrinter.Formatter.0.Lean.PrettyPrinter.Formatter.SourceInfo.getExprPos?.match_1 | Lean.PrettyPrinter.Formatter | (motive : Lean.SourceInfo → Sort u_1) →
(x : Lean.SourceInfo) →
((pos endPos : String.Pos.Raw) → (canonical : Bool) → motive (Lean.SourceInfo.synthetic pos endPos canonical)) →
((x : Lean.SourceInfo) → motive x) → motive x | false |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj_X | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C (CategoryTheory.Mon D)),
(CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).X = F.comp (CategoryTheory.... | true |
Lean.Compiler.LCNF.FloatLetIn.FloatState | Lean.Compiler.LCNF.FloatLetIn | Type | true |
IsQuantale.mk | Mathlib.Algebra.Order.Quantale | ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : CompleteLattice α],
(∀ (x : α) (s : Set α), x * sSup s = ⨆ y ∈ s, x * y) →
(∀ (s : Set α) (y : α), sSup s * y = ⨆ x ∈ s, x * y) → IsQuantale α | true |
Subsemiring.op_le_op_iff._simp_1 | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {S₁ S₂ : Subsemiring R}, (S₁.op ≤ S₂.op) = (S₁ ≤ S₂) | false |
AddConjClasses.forall_isAddConj | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : AddMonoid α] {p : AddConjClasses α → Prop},
(∀ (a : AddConjClasses α), p a) ↔ ∀ (a : α), p (AddConjClasses.mk a) | true |
CFC.sqrt_mul_sqrt_self | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalRing A] [inst_2 : TopologicalSpace A] [inst_3 : StarRing A]
[inst_4 : Module ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : Nonneg... | true |
_aux_Init_Core___unexpand_Inter_inter_1 | Init.Core | Lean.PrettyPrinter.Unexpander | false |
Lean.initFn._@.Lean.Meta.Constructions.NoConfusion.2636467839._hygCtx._hyg.4 | Lean.Meta.Constructions.NoConfusion | IO (Lean.Option Bool) | false |
CategoryTheory.ShortComplex.isLimitOfIsLimitπ._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (c : CategoryTheory.Limits.Cone F)
(h₁ : CategoryTheory.Limits.IsLimit (C... | false |
CategoryTheory.SingleObj.functor._proof_1 | Mathlib.CategoryTheory.SingleObj | ∀ {M : Type u_1} [inst : Monoid M] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C] {X : C}
(f : M →* CategoryTheory.End X) (x : CategoryTheory.SingleObj M), f 1 = 1 | false |
_private.Mathlib.Analysis.Normed.Group.Ultra.0.Finset.Nonempty.norm_prod_le_sup'_norm._simp_1_1 | Mathlib.Analysis.Normed.Group.Ultra | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a ≤ s.sup' H f) = ∃ b ∈ s, a ≤ f b | false |
CategoryTheory.Limits.HasCoreflexiveEqualizers.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.Limits.HasCoreflexiveEqualizers C → Sort u_1} →
(t : CategoryTheory.Limits.HasCoreflexiveEqualizers C) →
((has_eq :
∀ ⦃A B : C⦄ (f g : A ⟶ B) [CategoryTheory.IsCoreflexivePair f g],
Cate... | false |
Equiv.isEmpty_congr | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} (e : α ≃ β), IsEmpty α ↔ IsEmpty β | true |
List.cyclicPermutations_nil | Mathlib.Data.List.Rotate | ∀ {α : Type u}, [].cyclicPermutations = [[]] | true |
QuotientAddGroup.leftRel.eq_1 | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α), QuotientAddGroup.leftRel s = AddAction.orbitRel (↥s.op) α | true |
Affine.Triangle.altitudeFoot_mem_ninePointCircle | Mathlib.Geometry.Euclidean.NinePointCircle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : Affine.Triangle ℝ P) (i : Fin 3),
Affine.Simplex.altitudeFoot s i ∈ Affine.Simplex.ninePointCircle s | true |
ProbabilityTheory.Kernel.setLIntegral_rnDerivAux | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] (κ η : ProbabilityTheory.Kernel α γ)
[ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel η] (a : α) {s : Set γ},
MeasurableSet s → ∫⁻ (x : γ) in s, ENNReal... | true |
ContinuousOn.integrableAt_nhdsWithin_of_isSeparable | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : TopologicalSpace α]
[TopologicalSpace.PseudoMetrizableSpace α] [OpensMeasurableSpace α] {μ : MeasureTheory.Measure α}
[MeasureTheory.IsLocallyFiniteMeasure μ] {a : α} {t : Set α} {f : α → E},
ContinuousOn f t →
Me... | true |
CategoryTheory.WithTerminal.ofCommaObject_obj | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(c : CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Functor C D)) (CategoryTheory.Functor.const C))
(X : CategoryTheory.WithTerminal C),
(CategoryTheory.WithTerminal.ofCommaObje... | true |
Finpartition.card_filter_equitabilise_small | Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {m a b : ℕ} (P : Finpartition s)
(h : a * m + b * (m + 1) = s.card), m ≠ 0 → {u ∈ (Finpartition.equitabilise h).parts | u.card = m}.card = a | true |
_private.Mathlib.Algebra.Lie.Submodule.0.LieSubmodule.instIsArtinianSubtypeMem._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_1} {L : Type u_3} {M : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] [IsArtinian R M] (N : LieSubmodule R L M), IsArtinian R ↥N | false |
_private.Mathlib.Analysis.Real.OfDigits.0.Real.ofDigits_SurjOn._proof_1_3 | Mathlib.Analysis.Real.OfDigits | ∀ ⦃y : ℝ⦄, y ∈ Set.Icc 0 1 → y ∉ Set.Ico 0 1 → y = 1 | false |
Lean.Doc.initFn._@.Lean.Elab.DocString.4070225551._hygCtx._hyg.2 | Lean.Elab.DocString | IO (IO.Ref (Array (Lean.Name × Lean.Doc.CodeBlockSuggester))) | false |
CategoryTheory.yonedaCommGrpGrp_obj | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G : CategoryTheory.CommGrp C),
CategoryTheory.yonedaCommGrpGrp.obj G = CategoryTheory.yonedaCommGrpGrpObj G | true |
_private.Mathlib.Algebra.Polynomial.Basic.0.Polynomial.exists_iff_exists_finsupp.match_1_1 | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] (P : Polynomial R → Prop) (motive : (∃ p, P p) → Prop) (x : ∃ p, P p),
(∀ (p : AddMonoidAlgebra R ℕ) (hp : P { toFinsupp := p }), motive ⋯) → motive x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.