name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AddMonoidHom.fst.eq_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_3) (N : Type u_4) [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
AddMonoidHom.fst M N = { toFun := Prod.fst, map_zero' := ⋯, map_add' := ⋯ } | true |
CategoryTheory.NatTrans.retractArrowApp._proof_5 | Mathlib.CategoryTheory.Retract | ∀ {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] {F G : CategoryTheory.Functor C D} (τ : F ⟶ G) {X Y : C}
(h : CategoryTheory.Retract X Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.homMk (F.map h.i) (G.map h.i) ⋯)
(... | false |
Std.DTreeMap.getKey_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
{l : List ((a : α) × β a)} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → ∀ {h' : k' ∈ t.insertMany l}, (t.insertMany l).get... | true |
Lean.SimplePersistentEnvExtensionDescr.addImportedFn | Lean.EnvExtension | {α σ : Type} → Lean.SimplePersistentEnvExtensionDescr α σ → Array (Array α) → σ | true |
Fin.insertNthOrderIso_zero | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_2) [inst : (i : Fin (n + 1)) → LE (α i)],
Fin.insertNthOrderIso α 0 = Fin.consOrderIso α | true |
CategoryTheory.Functor.mapAction_map_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} W] (F : CategoryTheory.Functor V W) (G : Type u_3) [inst_2 : Monoid G]
{X Y : Action V G} (f : X ⟶ Y), ((F.mapAction G).map f).hom = F.map f.hom | true |
HomologicalComplex.IsSupported.mk._flat_ctor | Mathlib.Algebra.Homology.Embedding.IsSupported | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : HomologicalComplex C c'} {e : c.Embedding c'},
(∀ (i' : ι'), (∀ (i : ι), e.f i ≠ i') → K.ExactAt i') → K.IsSupported e | false |
Prefunctor.symmetrify | Mathlib.Combinatorics.Quiver.Symmetric | {U : Type u_1} →
{V : Type u_2} → [inst : Quiver U] → [inst_1 : Quiver V] → U ⥤q V → Quiver.Symmetrify U ⥤q Quiver.Symmetrify V | true |
OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge' | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c₀ : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c₁ : OmegaCompletePartialOrder.Chain α) (z : β),
(∀ (j i : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z | true |
Lean.Server.Test.Runner.Client.InfoPopup.mk | Lean.Server.Test.Runner | Option (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.SubexprInfo) →
Option (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.SubexprInfo) →
Option String → Lean.Server.Test.Runner.Client.InfoPopup | true |
FreeAddGroup.lift._proof_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup β] (f : α → β),
(fun g => ⇑g ∘ FreeAddGroup.of) ((fun f => AddMonoidHom.mk' (Quot.lift (FreeAddGroup.Lift.aux f) ⋯) ⋯) f) = f | false |
_private.Lean.Parser.Basic.0.Lean.Parser.longestMatchFn._sparseCasesOn_1 | Lean.Parser.Basic | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Left.mul_lt_one' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftMono α] {a b : α}, a < 1 → b < 1 → a * b < 1 | true |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.rightAnnihilator | Lean.Compiler.LCNF.Simp.ConstantFold | {α : Type} →
[Lean.Compiler.LCNF.Simp.ConstantFold.Literal α] →
[BEq α] →
(annihilator zero : α) →
(op : α → α → α) →
autoParam (∀ (x : α), op x annihilator = zero)
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.rightAnnihilator._auto_1 →
Lean.Compiler.LCNF.Simp.Cons... | true |
String.Legacy.Iterator.nextn._sunfold | Init.Data.String.Iterator | String.Legacy.Iterator → ℕ → String.Legacy.Iterator | false |
MulHom.ofDense.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_3} {N : Type u_4} [inst : Semigroup M] [inst_1 : Semigroup N] {s : Set M} (f : M → N)
(hs : Subsemigroup.closure s = ⊤) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y),
MulHom.ofDense f hs hmul = { toFun := f, map_mul' := ⋯ } | true |
CategoryTheory.SingleFunctors.instIsIsoFunctorHom | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A} (f : F ⟶ G)
[CategoryTheory.IsIso f] (n : A), CategoryTheory.IsIso ... | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso_inv_τ₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | true |
List.Subperm.idxInj._proof_3 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [ReflBEq α] {xs ys : List α},
xs.Subperm ys → ∀ (i : Fin xs.length), List.idxOfNth xs[↑i] ys (List.countBefore xs[i] xs ↑i) < ys.length | false |
Lean.SubExpr.GoalsLocation.mk | Lean.SubExpr | Lean.MVarId → Lean.SubExpr.GoalLocation → Lean.SubExpr.GoalsLocation | true |
Nat.eq_sq_add_sq_iff_eq_sq_mul | Mathlib.NumberTheory.SumTwoSquares | ∀ {n : ℕ}, (∃ x y, n = x ^ 2 + y ^ 2) ↔ ∃ a b, n = a ^ 2 * b ∧ IsSquare (-1) | true |
Lean.Firefox.SampleUnits.threadCPUDelta._default | Lean.Util.Profiler | String | false |
ae_lt_of_lt_essInf | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : ConditionallyCompleteLinearOrder β] {x : β} {f : α → β},
x < essInf f μ →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) (MeasureTheory.ae μ) f) ae_lt_of_lt_essInf._auto_1 →
∀ᵐ (y : α) ∂μ, x < f y | true |
String.contains_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (c : Char), String.Legacy.contains s c = true ↔ c ∈ s.toList | true |
CategoryTheory.Adjunction.CoreHomEquiv.mk.noConfusion | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
{P : Sort u} →
{homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ ... | false |
CompleteLat.casesOn | Mathlib.Order.Category.CompleteLat | {motive : CompleteLat → Sort u} →
(t : CompleteLat) →
((carrier : Type u_1) → [str : CompleteLattice carrier] → motive { carrier := carrier, str := str }) → motive t | false |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} [inst : TopologicalSpace R] [inst_1 : Semiring R] {ι : Type u_3}
(f : ι → MvPowerSeries σ R) (u : Filter ι) (g : MvPowerSeries σ R),
Filter.Tendsto f u (nhds g) =
∀ (d : σ →₀ ℕ), Filter.Tendsto (fun i => (MvPowerSeries.coeff d) (f i)) u (nhds ((MvPowerSeries.coeff d) g)) | false |
Module.annihilator_eq_bot | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_4} {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.annihilator R M = ⊥ ↔ FaithfulSMul R M | true |
AlgebraicGeometry.LocallyRingedSpace.evaluation_eq_zero_iff_notMem_basicOpen | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) {U : TopologicalSpace.Opens ↑X.toTopCat} (x : ↥U)
(f : ↑(X.presheaf.obj (Opposite.op U))),
(CategoryTheory.ConcreteCategory.hom (X.evaluation x)) f = 0 ↔ ↑x ∉ X.toRingedSpace.basicOpen f | true |
ModularForm | Mathlib.NumberTheory.ModularForms.Basic | Subgroup (GL (Fin 2) ℝ) → ℤ → Type | true |
Cardinal.lift_iSup | Mathlib.SetTheory.Cardinal.Basic | ∀ {ι : Type v} {f : ι → Cardinal.{w}},
BddAbove (Set.range f) → Cardinal.lift.{u, w} (iSup f) = ⨆ i, Cardinal.lift.{u, w} (f i) | true |
_private.Mathlib.Tactic.NormNum.NatFib.0.Mathlib.Meta.NormNum.proveNatFibAux.match_1 | Mathlib.Tactic.NormNum.NatFib | (en : Q(ℕ)) →
(motive : (ea' : Q(ℕ)) × (eb' : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea'» «$eb'») → Sort u_1) →
(x : (ea' : Q(ℕ)) × (eb' : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea'» «$eb'»)) →
((ea eb : Q(ℕ)) → (H : Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea» «$eb»)) → motive ⟨ea, ⟨eb, H⟩... | false |
ConvexCone.instAddCommSemigroup._proof_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (x x_1 x_2 : ConvexCone R M), x + x_1 + x_2 = x + (x_1 + x_2) | false |
CategoryTheory.BraidedCategory.tensorLeftIsoTensorRight | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] →
(X : C) → CategoryTheory.MonoidalCategory.tensorLeft X ≅ CategoryTheory.MonoidalCategory.tensorRight X | true |
List.isSome_minOn?_iff | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α},
(List.minOn? f xs).isSome = true ↔ xs ≠ [] | true |
_private.Lean.Language.Basic.0.Lean.Language.withHeaderExceptions.match_1 | Lean.Language.Basic | {α : Type} →
(motive : Except IO.Error α → Sort u_1) →
(__do_lift : Except IO.Error α) →
((e : IO.Error) → motive (Except.error e)) → ((a : α) → motive (Except.ok a)) → motive __do_lift | false |
CategoryTheory.MorphismProperty.multiplicativeClosure.below | Mathlib.CategoryTheory.MorphismProperty.Composition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure x → Prop} →
{X Y : C} → {x : X ⟶ Y} → W.multiplicativeClosure x → Prop | true |
LinearIsometry.isEmbedding | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E₂ : Type u_6} {F : Type u_9} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E₂] [inst_3 : Module R₂ E₂] [inst_4 : NormedAddCommGroup F]
[inst_5 : Module R F] (f : F →ₛₗᵢ[σ₁₂] E₂), Topology.IsEmbedding ⇑f | true |
Sublocale.carrier.instCompleteLattice._proof_9 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {S : Sublocale X} (s : Set ↥S), IsGLB s (sInf s) | false |
Std.ExtTreeSet.get!_inter_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α]
{k : α}, k ∉ t₁ → (t₁ ∩ t₂).get! k = default | true |
AnalyticOnNhd.is_constant_or_isOpen | Mathlib.Analysis.Complex.OpenMapping | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {U : Set E} {g : E → ℂ},
AnalyticOnNhd ℂ g U → IsPreconnected U → (∃ w, ∀ z ∈ U, g z = w) ∨ ∀ s ⊆ U, IsOpen s → IsOpen (g '' s) | true |
Lean.Elab.Tactic.evalApply._regBuiltin.Lean.Elab.Tactic.evalApply_1 | Lean.Elab.Tactic.ElabTerm | IO Unit | false |
CochainComplex.HomComplex.Cocycle.isKernel._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m : ℤ) (hm : n + 1 = m) (s : CategoryTheory.Limits.Fork ((K.HomComplex L).d n m) 0),
CategoryTheory.CategoryStruct.comp
((fun s =>
AddCommGrpCat.ofHom
{ to... | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkItem.mk._flat_ctor | Init.Data.Format.Basic | Std.Format → ℤ → ℕ → Std.Format.WorkItem✝ | false |
CategoryTheory.Localization.Construction.LocQuiver.ctorIdx | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{W : CategoryTheory.MorphismProperty C} → CategoryTheory.Localization.Construction.LocQuiver W → ℕ | false |
_private.Mathlib.RingTheory.Smooth.AdicCompletion.0.Algebra.FormallySmooth.liftAdicCompletionAux | Mathlib.RingTheory.Smooth.AdicCompletion | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
{S : Type u_3} →
[inst_3 : CommRing S] →
[inst_4 : Algebra R S] →
(I : Ideal S) → (A →ₐ[R] S ⧸ I) → [Algebra.FormallySmooth R A] → (m : ℕ) → A ... | true |
CommGroupWithZero.instNormalizedGCDMonoid._proof_9 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] (a b : G₀),
¬(a = 0 ∧ b = 0) → normalize (if a = 0 ∧ b = 0 then 0 else 1) = if a = 0 ∧ b = 0 then 0 else 1 | false |
_private.Mathlib.Data.Set.Accumulate.0.Set.exists_accumulate_eq_univ_iff_of_directed._proof_1_3 | Mathlib.Data.Set.Accumulate | ∀ {α : Type u_1} {s : ℕ → Set α},
(∀ (n : ℕ), s n ≠ Set.univ) → ∀ (n m : ℕ), Set.accumulate s n ⊆ s m → ¬Set.accumulate s n = Set.univ | false |
_private.Mathlib.Order.Category.Preord.0.Preord.Hom.mk.injEq | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (hom' hom'_1 : ↑X →o ↑Y), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | true |
LieSubmodule.mk._flat_ctor | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : LieRingModule L M] →
(carrier : Set M) →
(∀ {a b : M}, a ∈ carrier → b ∈ carri... | false |
MeasureTheory.L1.SimpleFunc.setToL1SCLM._proof_2 | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T : Set α → E →L[ℝ] F} {C : ℝ},
MeasureTheory.DominatedFinMeasAdditive μ T C →
∀ (c : ℝ) (f ... | false |
Int.isCompl_even_odd | Mathlib.Algebra.Order.Ring.Int | IsCompl {n | Even n} {n | Odd n} | true |
CompHausLike.coproductIsColimit._proof_2 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) [inst : CompHausLike.HasProp P (↑X.toTop ⊕ ↑Y.toTop)]
(s : CategoryTheory.Limits.BinaryCofan X Y),
CategoryTheory.CategoryStruct.comp (CompHausLike.ofHom P { toFun := Sum.inl, continuous_toFun := ⋯ })
((fun s =>
CompHausLike.ofHom P
{
... | false |
_private.Mathlib.Lean.MessageData.ForExprs.0.Lean.MessageData.forExprsIn.go.match_7 | Mathlib.Lean.MessageData.ForExprs | {σ : Type} →
(motive : Option (ForInStep σ) → Sort u_1) →
(x : Option (ForInStep σ)) → (Unit → motive none) → ((a : ForInStep σ) → motive (some a)) → motive x | false |
AffineMap.pi_apply | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_2} {V1 : Type u_3} {P1 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : AddTorsor V1 P1]
[inst_3 : Module k V1] {ι : Type u_9} {φv : ι → Type u_10} {φp : ι → Type u_11}
[inst_4 : (i : ι) → AddCommGroup (φv i)] [inst_5 : (i : ι) → Module k (φv i)]
[inst_6 : (i : ι) → AddTorsor (φv i) ... | true |
MeasureTheory.SimpleFunc.exists_upperSemicontinuous_le_lintegral_le | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] {μ : MeasureTheory.Measure α}
[μ.WeaklyRegular] (f : MeasureTheory.SimpleFunc α NNReal),
∫⁻ (x : α), ↑(f x) ∂μ ≠ ⊤ →
∀ {ε : ENNReal},
ε ≠ 0 → ∃ g, (∀ (x : α), g x ≤ f x) ∧ UpperSemicontinuous g ∧ ∫⁻ (x : α), ↑(f x) ∂μ... | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.DerivedLitsInvariant.congr_simp | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f f_1 : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (e_f : f = f_1)
(fassignments_size : f.assignments.size = n)
(assignments assignments_1 : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(e_assignments : assignments = assignments_1) (assignments_size : assignments.size = n)
(derivedLit... | true |
Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof.brecOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof) →
((t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr) → t.below → motive_1 t) →
((t : Lean.Meta.Grind.Ari... | false |
UniformSpace.Completion.instField._proof_13 | Mathlib.Topology.Algebra.UniformField | ∀ {K : Type u_1} [inst : Field K] [inst_1 : UniformSpace K] [inst_2 : IsTopologicalDivisionRing K]
[inst_3 : IsUniformAddGroup K] (x : UniformSpace.Completion K), Semiring.npow 0 x = 1 | false |
SubAddAction.SMulMemClass.subtype | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} →
{M : Type v} →
[inst : AddMonoid R] →
[inst_1 : AddAction R M] →
{A : Type u_1} → [inst_2 : SetLike A M] → [hA : VAddMemClass A R M] → (S' : A) → ↥S' →ₑ[id] M | true |
Finsupp.lcoeFun | Mathlib.LinearAlgebra.Finsupp.Pi | {α : Type u_1} →
{M : Type u_2} →
{R : Type u_5} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (α →₀ M) →ₗ[R] α → M | true |
Turing.TM2to1.StAct.ctorElimType | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} → {motive : Turing.TM2to1.StAct K Γ σ k → Sort u} → ℕ → Sort (max 1 (imax (max (u_2 + 1) (u_4 + 1)) u)) | false |
_private.Mathlib.AlgebraicGeometry.Noetherian.0.AlgebraicGeometry.isNoetherian_Spec._simp_1_1 | Mathlib.AlgebraicGeometry.Noetherian | ∀ (X : AlgebraicGeometry.Scheme),
AlgebraicGeometry.IsNoetherian X = (AlgebraicGeometry.IsLocallyNoetherian X ∧ CompactSpace ↥X) | false |
Std.DTreeMap.Internal.RoiSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Roi α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | true |
CategoryTheory.Limits.pushout.hom_ext_iff | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] {W : C} {k l : CategoryTheory.Limits.pushout f g ⟶ W},
k = l ↔
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g) k =
CategoryTheory.Catego... | true |
HomologicalComplex.Hom.isoOfComponents_hom_f | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : (i : ι) → C₁.X i ≅ C₂.X i)
(hf :
autoParam
(∀ (i j : ι),
c.Rel i j →
CategoryTheory.CategoryStruct.comp... | true |
Subsemigroup.comap_le_comap_iff_of_surjective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Surjective ⇑f → ∀ {S T : Subsemigroup N}, Subsemigroup.comap f S ≤ Subsemigroup.comap f T ↔ S ≤ T | true |
groupHomology.H0π.eq_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
groupHomology.H0π A = CategoryTheory.CategoryStruct.comp (groupHomology.cyclesIso₀ A).inv (groupHomology.π A 0) | true |
OrderMonoidWithZeroHom.ext_iff | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
[inst_3 : MulZeroOneClass β] {f g : α →*₀o β}, f = g ↔ ∀ (a : α), f a = g a | true |
instIsPrincipalIdealRingOfIsSemisimpleRing | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] [IsSemisimpleRing R], IsPrincipalIdealRing R | true |
Std.TreeMap.Raw.instLawfulSingletonProd | Std.Data.TreeMap.Raw.Basic | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, LawfulSingleton (α × β) (Std.TreeMap.Raw α β cmp) | true |
isGreatest_singleton._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsGreatest {a} a = True | false |
AddCancelMonoid.noConfusion | Mathlib.Algebra.Group.Defs | {P : Sort u_1} →
{M : Type u} →
{t : AddCancelMonoid M} →
{M' : Type u} → {t' : AddCancelMonoid M'} → M = M' → t ≍ t' → AddCancelMonoid.noConfusionType P t t' | false |
Lean.Lsp.SymbolKind.number.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 15 → motive Lean.Lsp.SymbolKind.number → motive t | false |
Array.extract_append_right | Init.Data.Array.Extract | ∀ {α : Type u_1} {i : ℕ} {as bs : Array α}, (as ++ bs).extract as.size (as.size + i) = bs.extract 0 i | true |
WithAbs.ofAbs_pow | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) (x : WithAbs v) (n : ℕ), (x ^ n).ofAbs = x.ofAbs ^ n | true |
Finset.PNat.coe_prod | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_4} (f : ι → ℕ+) (s : Finset ι), ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i) | true |
_private.Init.Data.String.Lemmas.Pattern.Split.0.String.Slice.Pattern.Model.splitFromSteps.match_1.eq_1 | Init.Data.String.Lemmas.Pattern.Split | ∀ {s : String.Slice} (motive : List (String.Slice.Pattern.SearchStep s) → Sort u_1) (h_1 : Unit → motive [])
(h_2 :
(startPos endPos : s.Pos) →
(l : List (String.Slice.Pattern.SearchStep s)) →
motive (String.Slice.Pattern.SearchStep.rejected startPos endPos :: l))
(h_3 :
(p q : s.Pos) →
... | true |
Set.insert_Ioc_right_eq_Ioc_add_one_of_not_isMax | Mathlib.Algebra.Order.Interval.Set.SuccPred | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : One α] [inst_2 : Add α] [SuccAddOrder α] {a b : α},
a ≤ b → ¬IsMax b → insert (b + 1) (Set.Ioc a b) = Set.Ioc a (b + 1) | true |
Std.DHashMap.erase_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {k : α}, ∅.erase k = ∅ | true |
CategoryTheory.Pseudofunctor.casesOn | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{motive : CategoryTheory.Pseudofunctor B C → Sort u} →
(t : CategoryTheory.Pseudofunctor B C) →
((toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C) →
... | false |
Polynomial.isNilpotent_aeval_sub_of_isNilpotent_sub | Mathlib.RingTheory.Polynomial.Nilpotent | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (P : Polynomial R)
{a b : S}, IsNilpotent (a - b) → IsNilpotent ((Polynomial.aeval a) P - (Polynomial.aeval b) P) | true |
Batteries.Tactic.GeneralizeProofs.Config.mk.inj | Batteries.Tactic.GeneralizeProofs | ∀ {maxDepth : ℕ} {abstract debug : Bool} {maxDepth_1 : ℕ} {abstract_1 debug_1 : Bool},
{ maxDepth := maxDepth, abstract := abstract, debug := debug } =
{ maxDepth := maxDepth_1, abstract := abstract_1, debug := debug_1 } →
maxDepth = maxDepth_1 ∧ abstract = abstract_1 ∧ debug = debug_1 | true |
CategoryTheory.Functor.IsCocartesian.toIsHomLift | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} {inst : CategoryTheory.Category.{v₁, u₁} 𝒮} {inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳}
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [self : p.IsCocartesian f φ],
p.IsHomLift f φ | true |
padicNorm.eq_zpow_of_nonzero | Mathlib.NumberTheory.Padics.PadicNorm | ∀ {p : ℕ} {q : ℚ}, q ≠ 0 → padicNorm p q = ↑p ^ (-padicValRat p q) | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Specialize.0.Lean.Elab.Tactic.Do.ProofMode.mSpecializeImpStateful._sparseCasesOn_11 | Lean.Elab.Tactic.Do.ProofMode.Specialize | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Std.DTreeMap.Internal.Impl.decidableEquiv | Std.Data.DTreeMap.Internal.Lemmas | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
[Std.LawfulEqOrd α] →
[inst_3 : (k : α) → BEq (β k)] →
[∀ (k : α), LawfulBEq (β k)] →
(t₁ t₂ : Std.DTreeMap.Internal.Impl α β) → t₁.WF → t₂.WF → Decidable (t₁.Equiv t₂) | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isNonTrivialRegular.isSimple.match_1 | Lean.Meta.ExprDefEq | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((m... | false |
SemiRingCat.hasForgetToMonCat._proof_4 | Mathlib.Algebra.Category.Ring.Basic | { obj := fun R => MonCat.of ↑R, map := fun {X Y} f => MonCat.ofHom ↑(SemiRingCat.Hom.hom f),
map_id := SemiRingCat.hasForgetToMonCat._proof_1, map_comp := @SemiRingCat.hasForgetToMonCat._proof_2 }.comp
(CategoryTheory.forget MonCat) =
CategoryTheory.forget SemiRingCat | false |
rothNumberNat_spec | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ (n : ℕ), ∃ t ⊆ Finset.range n, t.card = rothNumberNat n ∧ ThreeAPFree ↑t | true |
Lean.Elab.Term.ElabElim.Context.mk.noConfusion | Lean.Elab.App | {P : Sort u} →
{elimInfo : Lean.Elab.Term.ElabElimInfo} →
{expectedType : Lean.Expr} →
{elimInfo' : Lean.Elab.Term.ElabElimInfo} →
{expectedType' : Lean.Expr} →
{ elimInfo := elimInfo, expectedType := expectedType } =
{ elimInfo := elimInfo', expectedType := expectedType' } →... | false |
List.Nodup.mem_diff_iff | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l₁ l₂ : List α} {a : α} [inst : BEq α] [LawfulBEq α], l₁.Nodup → (a ∈ l₁.diff l₂ ↔ a ∈ l₁ ∧ a ∉ l₂) | true |
_private.Batteries.Data.Char.Basic.0.Char.exists_eq_false_of_all_eq_false._proof_1_9 | Batteries.Data.Char.Basic | ∀ (x : Fin 1056768),
↑x + (Char.maxSurrogate + 1) < 55296 ∨ 57343 < ↑x + (Char.maxSurrogate + 1) ∧ ↑x + (Char.maxSurrogate + 1) < 1114112 | false |
unitsNonZeroDivisorsEquiv._proof_4 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀],
Function.RightInverse (fun u => { val := ⟨↑u, ⋯⟩, inv := ⟨↑u⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ })
(↑(Units.map (nonZeroDivisors M₀).subtype)).toFun | false |
CategoryTheory.ShortComplex.rightHomologyι_naturality' | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂)... | true |
Mathlib.Tactic.Order.OrderType.ctorIdx | Mathlib.Tactic.Order.Preprocessing | Mathlib.Tactic.Order.OrderType → ℕ | false |
List.zipWithM'.eq_def | Init.Data.List.Monadic | ∀ {m : Type u → Type v} [inst : Monad m] {α : Type w} {β : Type x} {γ : Type u} (f : α → β → m γ) (x : List α)
(x_1 : List β),
List.zipWithM' f x x_1 =
match x, x_1 with
| x :: xs, y :: ys => do
let z ← f x y
let zs ← List.zipWithM' f xs ys
pure (z :: zs)
| x, x_2 => pure [] | true |
Complex.ofRealCLM_norm | Mathlib.Analysis.Complex.OperatorNorm | ‖Complex.ofRealCLM‖ = 1 | true |
Nat.induct_roo_right | Init.Data.Range.Polymorphic.NatLemmas | ∀ (motive : ℕ → ℕ → Prop),
(∀ (a b : ℕ), b ≤ a + 1 → motive a b) →
(∀ (a b : ℕ), a + 1 ≤ b → motive a b → motive a (b + 1)) → ∀ (a b : ℕ), motive a b | true |
Profinite.NobelingProof.factors._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Span | ∀ {I : Type u_1} [inst : LinearOrder I], IsTrans I fun x1 x2 => x2 ≤ x1 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.