name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.RingTheory.LocalRing.ResidueField.Ideal.0.instIsFractionRingQuotientIdealResidueField._simp_3 | Mathlib.RingTheory.LocalRing.ResidueField.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] (x y : R),
(x - y ∈ I) = ((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) | false |
HomotopyEquiv.toHomologyIso._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {K L : HomologicalComplex C c} (h : HomotopyEquiv K L) (i : ι) [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i],
CategoryTheory.CategoryStruct.comp (HomologicalComplex.ho... | false |
IsOpen.is_const_of_deriv_eq_zero | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {f : 𝕜 → G}
{s : Set 𝕜},
IsOpen s → IsPreconnected s → DifferentiableOn 𝕜 f s → Set.EqOn (deriv f) 0 s → ∀ {x y : 𝕜}, x ∈ s → y ∈ s → f x = f y | true |
Std.IterM.fold_filterMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_2 : Monad m] [LawfulMonad m] [inst_4 : Monad n] [inst_5 : MonadAttach n]
[LawfulMonad n] [WeaklyLawfulMonadAttach n] [inst_8 : Std.IteratorLoop α m n] [Std.LawfulIteratorLoop α m n]
[in... | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.mk | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
{F : CategoryTheory.Functor C FintypeCat} →
{A B : CategoryTheory.PreGaloisCategory.PointedGaloisObject F} →
(val : A.obj ⟶ B.obj) →
autoParam ((CategoryTheory.ConcreteCat... | true |
Std.DTreeMap.Internal.Impl.getKeyLE?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α),
Std.DTreeMap.Internal.Impl.getKeyLE? k = Std.DTreeMap.Internal.Impl.getKeyLE?.go k none | true |
MulAction.stabilizer_smul_eq_right | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {β : Type u_3} [inst : Group G] [inst_1 : MulAction G β] {α : Type u_4} [inst_2 : Group α]
[inst_3 : MulAction α β] [SMulCommClass G α β] (a : α) (b : β),
MulAction.stabilizer G (a • b) = MulAction.stabilizer G b | true |
map_eq_zero._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {M₀' : Type u_4} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : MulZeroOneClass M₀']
[Nontrivial M₀'] [inst_3 : FunLike F G₀ M₀'] [MonoidWithZeroHomClass F G₀ M₀'] (f : F) {a : G₀}, (f a = 0) = (a = 0) | false |
Std.Internal.IO.Async.System.OSInfo.mk.inj | Std.Internal.Async.System | ∀ {name release version machine name_1 release_1 version_1 machine_1 : String},
{ name := name, release := release, version := version, machine := machine } =
{ name := name_1, release := release_1, version := version_1, machine := machine_1 } →
name = name_1 ∧ release = release_1 ∧ version = version_1 ∧ ma... | true |
Lean.Expr.NumApps.State.counters | Lean.Util.NumApps | Lean.Expr.NumApps.State → Lean.NameMap ℕ | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.smul_add._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, (s ∪ t).IsPWO = (s.IsPWO ∧ t.IsPWO) | false |
NumberField.IsCMField.isConj_complexConj | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (φ : K →+* ℂ),
NumberField.ComplexEmbedding.IsConj φ (NumberField.IsCMField.complexConj K) | true |
Nat.nth_add_one | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} {n : ℕ}, ¬p 0 → Nat.nth p n ≠ 0 → Nat.nth (fun i => p (i + 1)) n + 1 = Nat.nth p n | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.completeBipartiteGraph_isContained_iff.match_1_7 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_2} {G : SimpleGraph V} {α : Type u_3} {β : Type u_1} [inst : Fintype β]
(f : (completeBipartiteGraph α β).Copy G) (x : V)
(motive : (∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x) → Prop)
(hr : ∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x),
(∀ (w : β) (left : w ∈ F... | false |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂),
CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₃ f₁₂ f₃ f₄).map' 0 1 C... | false |
CategoryTheory.Pseudofunctor.CoGrothendieck.noConfusion | Mathlib.CategoryTheory.Bicategory.Grothendieck | {P : Sort u} →
{𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} →
{t : F.CoGrothendieck} →
{𝒮' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} 𝒮'} →
... | false |
CochainComplex.HomComplex.CohomologyClass.toSmallShiftedHom | Mathlib.Algebra.Homology.DerivedCategory.SmallShiftedHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{K L : CochainComplex C ℤ} →
{n : ℤ} →
[inst_2 :
CategoryTheory.Localization.HasSmallLocalizedShiftedHom
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) ℤ K L]... | true |
Function.Surjective.involutiveNeg._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Neg M₂] [inst_1 : InvolutiveNeg M₁] (f : M₁ → M₂),
(∀ (x : M₁), f (-x) = -f x) → ∀ (x : M₁), - -f x = f x | false |
_private.Init.Data.Array.Find.0.Array.getElem?_zero_flatten._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {l : List α}, l[0]? = l.head? | false |
Std.DTreeMap.Raw.Equiv.forIn_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} {δ : Type w}
{m : Type w → Type w'} [Std.TransCmp cmp] [inst : Monad m] [LawfulMonad m] {b : δ}
{f : (a : α) × β a → δ → m (ForInStep δ)}, t₁.WF → t₂.WF → t₁.Equiv t₂ → forIn t₁ b f = forIn t₂ b f | true |
Subgroup.mulSingle_mem_pi._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), (Pi.mulSingle i x ∈ Subgroup.pi I H) = (i ∈ I → x ∈ H i) | false |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceOpcyclesE_X₁ | 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₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.Cat... | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_12 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | (ComplexShape.embeddingUpIntLE 0).IsTruncLE | false |
_private.Init.Omega.Int.0.Lean.Omega.Fin.ne_iff_lt_or_gt._simp_1_1 | Init.Omega.Int | ∀ {a b : ℕ}, (a ≠ b) = (a < b ∨ b < a) | false |
genLoopEquivOfUnique._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} (N : Type u_2) [inst_1 : Unique N] (p : LoopSpace X x),
{ toFun := fun c => p (c default), continuous_toFun := ⋯ } ∈ GenLoop N X x | false |
Lean.Server.instMonadLiftCancellableMRequestM.match_1 | Lean.Server.Requests | {α : Type} →
(motive : Except Lean.Server.RequestCancellation α → Sort u_1) →
(r : Except Lean.Server.RequestCancellation α) →
((a : Lean.Server.RequestCancellation) → motive (Except.error a)) → ((v : α) → motive (Except.ok v)) → motive r | false |
CategoryTheory.PrelaxFunctorStruct.map₂ | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | {B : Type u₁} →
[inst : Quiver B] →
[inst_1 : (a b : B) → Quiver (a ⟶ b)] →
{C : Type u₂} →
[inst_2 : Quiver C] →
[inst_3 : (a b : C) → Quiver (a ⟶ b)] →
(self : CategoryTheory.PrelaxFunctorStruct B C) →
{a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (self.map f ⟶ self.map... | true |
ArchimedeanClass.closedBallAddSubgroup.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M]
(c : ArchimedeanClass M), c.closedBallAddSubgroup = ArchimedeanClass.addSubgroup (UpperSet.Ici c) | true |
Std.DTreeMap.Internal.Const.RicSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Const.RicSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => β) →
(range : Std.Ric α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Const.Ric... | false |
Lean.Data.AC.Variable.mk | Init.Data.AC | {α : Sort u} → {op : α → α → α} → (value : α) → Option (PLift (Std.LawfulIdentity op value)) → Lean.Data.AC.Variable op | true |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow_covBySMul_sq_inter_sq._simp_1_10 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
CommRingCat.Colimits.Prequotient.noConfusion | Mathlib.Algebra.Category.Ring.Colimits | {P : Sort u} →
{J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
{F : CategoryTheory.Functor J CommRingCat} →
{t : CommRingCat.Colimits.Prequotient F} →
{J' : Type v} →
{inst' : CategoryTheory.SmallCategory J'} →
{F' : CategoryTheory.Functor J' CommRingCat}... | false |
PartOrd.dual | Mathlib.Order.Category.PartOrd | CategoryTheory.Functor PartOrd PartOrd | true |
Int.ModEq.prod_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {f : α → ℤ} {s : Finset α}, (∀ x ∈ s, f x ≡ 1 [ZMOD n]) → ∏ x ∈ s, f x ≡ 1 [ZMOD n] | true |
Lean.Parser.Term.stateRefT._regBuiltin.Lean.Parser.Term.macroDollarArg.formatter_11 | Lean.Parser.Term | IO Unit | false |
CategoryTheory.Adjunction.leftAdjointUniq_trans_assoc | Mathlib.CategoryTheory.Adjunction.Unique | ∀ {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] {F F' F'' : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G) (adj3 : F'' ⊣ G) {Z : CategoryTheory.Functor C D}
(h : F'' ⟶ Z),
CategoryTheory.Ca... | true |
_private.Mathlib.MeasureTheory.Integral.PeakFunction.0.tendsto_integral_comp_smul_smul_of_integrable._simp_1_3 | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) | false |
UInt64.toNat_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt64), (-a).toNat = (UInt64.size - a.toNat) % UInt64.size | true |
Aesop.GoalState.toNodeState | Aesop.Tree.Data | Aesop.GoalState → Aesop.NodeState | true |
MeasureTheory.Measure.FiniteSpanningSetsIn.disjointed_set_eq | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(S : μ.FiniteSpanningSetsIn {s | MeasurableSet s}), S.disjointed.set = disjointed S.set | true |
NNReal.arith_mean_le_rpow_mean | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → NNReal),
∑ i ∈ s, w i = 1 → ∀ {p : ℝ}, 1 ≤ p → ∑ i ∈ s, w i * z i ≤ (∑ i ∈ s, w i * z i ^ p) ^ (1 / p) | true |
CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ {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] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C))
(j : J), (CategoryTheory.CategoryStruct.comp P.p P.p).app j = P.p.app j | false |
String.isInt | Init.Data.String.Search | String → Bool | true |
CategoryTheory.Under.forgetCone._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) ⦃X_1 Y : CategoryTheory.Under X⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Under X)).obj X).map f) Y.hom =
CategoryTheory.CategoryStruct.comp X_1.hom ((CategoryTheory.Under.forget X).map ... | false |
CategoryTheory.MonoidalClosed.enrichedCategorySelf_id | Mathlib.CategoryTheory.Monoidal.Closed.Enrichment | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.MonoidalClosed C] (X : C), CategoryTheory.eId C X = CategoryTheory.MonoidalClosed.id X | true |
Lean.Parser.Term.letOptUsedOnly._regBuiltin.Lean.Parser.Term.letOptUsedOnly.docString_1 | Lean.Parser.Term | IO Unit | false |
Std.DTreeMap.Raw.get!_eq_default | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {a : α} [inst_1 : Inhabited (β a)], a ∉ t → t.get! a = default | true |
Finset.isScalarTower' | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq γ] [inst_1 : DecidableEq β] [inst_2 : SMul α β]
[inst_3 : SMul α γ] [inst_4 : SMul β γ] [IsScalarTower α β γ], IsScalarTower α (Finset β) (Finset γ) | true |
_private.Mathlib.LinearAlgebra.Basis.Exact.0.Submodule.linearProjOfIsCompl_comp_bijective_of_exact._simp_1_1 | Mathlib.LinearAlgebra.Basis.Exact | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {p : Submodule R M}, Set.InjOn ⇑f ↑p = Disjoint p f.ker | false |
Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.MinImports.2495106528._hygCtx._hyg.4 | Mathlib.Tactic.Linter.MinImports | IO (Lean.Option Bool) | false |
FirstOrder.Language.IsFraisse.is_equiv_invariant | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)} [h : FirstOrder.Language.IsFraisse K]
{M N : CategoryTheory.Bundled L.Structure}, Nonempty (L.Equiv ↑M ↑N) → (M ∈ K ↔ N ∈ K) | true |
PiLp.nnnorm_single | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [hp : Fact (1 ≤ p)] [inst : Fintype ι]
[inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_2 : DecidableEq ι] (i : ι) (b : β i),
‖PiLp.single p i b‖₊ = ‖b‖₊ | true |
String.take_eq | Batteries.Data.String.Lemmas | ∀ (s : String) (n : ℕ), String.Legacy.take s n = String.ofList (List.take n s.toList) | true |
Preord.inv_hom_apply | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (e : X ≅ Y) (x : ↑X),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | true |
Batteries.RBSet.upperBound?_mem_toList | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x y : α} {t : Batteries.RBSet α cmp}, t.upperBound? x = some y → y ∈ t.toList | true |
CategoryTheory.Presheaf.isSheaf_iff_extensiveSheaf_of_projective | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] (F : CategoryTheory.Functor Cᵒᵖ A)
[inst_2 : CategoryTheory.Preregular C] [inst_3 : CategoryTheory.FinitaryExtensive C]
[∀ (X : C), CategoryTheory.Projective X],
CategoryTheory.Presheaf.IsS... | true |
Frm.Hom.recOn | Mathlib.Order.Category.Frm | {X Y : Frm} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : FrameHom ↑X ↑Y) → motive { hom' := hom' }) → motive t | false |
Polynomial.one_le_cauchyBound._simp_1 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {K : Type u_1} [inst : NormedDivisionRing K] (p : Polynomial K), (1 ≤ p.cauchyBound) = True | false |
Std.ExtTreeMap.getKey!_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α}, cmp k k' = Ordering.eq → t.getKey! k = t.getKey! k' | true |
Membership.noConfusionType | Init.Prelude | Sort u_1 → {α : Type u} → {γ : Type v} → Membership α γ → {α' : Type u} → {γ' : Type v} → Membership α' γ' → Sort u_1 | false |
HahnSeries.SummableFamily.instModule._proof_10 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_4} {R : Type u_2} {V : Type u_5} {α : Type u_3} [inst : AddCommMonoid Γ]
[inst_1 : PartialOrder Γ] [inst_2 : PartialOrder Γ'] [inst_3 : AddAction Γ Γ'] [inst_4 : IsOrderedCancelVAdd Γ Γ']
[inst_5 : Semiring R] [inst_6 : AddCommMonoid V] [inst_7 : Module R V] (x : HahnSeries Γ R)
(x_1... | false |
Bipointed.toProd | Mathlib.CategoryTheory.Category.Bipointed | (self : Bipointed) → self.X × self.X | true |
String.Pos.Raw.offsetOfPos | Init.Data.String.Basic | String → String.Pos.Raw → ℕ | true |
Mathlib.Tactic.IntervalCases.Methods.roundDown | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocsExt.match_3 | Lean.Linter.MissingDocs | (motive : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler → Sort u_1) →
(x : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler) →
((n k : Lean.Name) → (h : Lean.Linter.MissingDocs.Handler) → motive (n, k, h)) → motive x | false |
CentroidHom.applyModule._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), f 0 = 0 | false |
SheafOfModules.Presentation.isColimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCo... | false |
SubmodulesRingBasis.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
{B : ι → Submodule R A},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) →
(∀ (a : A) (i : ι), ∃ j, a • B j ≤ B i) → (∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)) → SubmodulesRingBasis B | false |
Lean.Server.Test.Runner.Client.InteractiveTermGoal.noConfusionType | Lean.Server.Test.Runner | Sort u →
Lean.Server.Test.Runner.Client.InteractiveTermGoal → Lean.Server.Test.Runner.Client.InteractiveTermGoal → Sort u | false |
RelSeries.last_drop | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length + 1)), (p.drop i).last = p.last | true |
Function.locallyFinsuppWithin.addSubgroup._proof_1 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] (U : Set X) {Y : Type u_2} [inst_1 : AddGroup Y] {f : X → Y},
f ∈ {f | Function.support f ⊆ U ∧ ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support f).Finite} →
-f ∈ {f | Function.support f ⊆ U ∧ ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support f).Finite} | false |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_X₁ | 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 |
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.handleCodeActionResolve.match_3 | Lean.Server.CodeActions.Basic | (motive : Option (IO Lean.Lsp.CodeAction) → Sort u_1) →
(x : Option (IO Lean.Lsp.CodeAction)) →
((lazy : IO Lean.Lsp.CodeAction) → motive (some lazy)) →
((x : Option (IO Lean.Lsp.CodeAction)) → motive x) → motive x | false |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn._regBuiltin._private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn.docString_1._@.Lean.Meta.Constructions.CtorElim.299025572._hygCtx._hyg.2 | Lean.Meta.Constructions.CtorElim | IO Unit | false |
Lean.Syntax.TSepArray.mk | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → {sep : String} → Array Lean.Syntax → Lean.Syntax.TSepArray ks sep | true |
Lean.Int.mkInstHPow | Lean.Expr | Lean.Expr | true |
ContMDiffSection.toFun | Mathlib.Geometry.Manifold.VectorBundle.SmoothSection | {𝕜 : 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} →
... | true |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.SummableFamily.hsum._simp_1 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) | false |
Finsupp.mapRange.equiv._proof_2 | Mathlib.Data.Finsupp.Defs | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Zero M] [inst_1 : Zero N] (e : M ≃ N) (hf : e 0 = 0)
(x : ι →₀ M), Finsupp.mapRange ⇑e.symm ⋯ (Finsupp.mapRange (⇑e) hf x) = x | false |
WithTop.instMulZeroOneClass._proof_2 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroOneClass α] [Nontrivial α] (x : WithTop α), x * 1 = x | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_324 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] 1)) <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.MorL | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Month.Ordinal | true |
Std.TreeMap.getKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α}
{v : β} {h₁ : a ∈ t.insert k v}, (t.insert k v).getKey a h₁ = if h₂ : cmp k a = Ordering.eq then k else t.getKey a ⋯ | true |
Submodule.toLocalized' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_1} →
(S : Type u_2) →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | true |
le_sup_iff._simp_3 | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) | false |
isGLB_ciInf_set | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : β → α} {s : Set β},
BddBelow (f '' s) → s.Nonempty → IsGLB (f '' s) (⨅ i, f ↑i) | true |
Fin.one_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n], 1 = 0 ↔ n = 1 | true |
Finset.attach_empty | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1}, ∅.attach = ∅ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.filter_equiv_self_iff._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | false |
Finset.exists_subsuperset_card_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s t : Finset α} {n : ℕ}, s ⊆ t → s.card ≤ n → n ≤ t.card → ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.card = n | true |
SheafOfModules.mk.noConfusion | Mathlib.Algebra.Category.ModuleCat.Sheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
{P : Sort u_1} →
{val : PresheafOfModules R.obj} →
{isSheaf : CategoryTheory.Presheaf.IsSheaf J val.presheaf} →
{val'... | false |
Orientation.rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)), o.rotation ↑(Real.pi / 2) = o.rightAngleRotation | true |
MeasureTheory.Measure.isAddLeftInvariant_eq_smul_of_innerRegular | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsAddHaarMeasure] [inst_7 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsAddLe... | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ring.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof) →
t.ctorIdx = 2 →
((c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr) →
(lhs : Lean.Meta.Grind.Arith.Linear.LinExpr) →
motive_4 (Lean.Meta.Grind.Arith.Linear.IneqCnstrPro... | false |
String.posGE_eq_posGE_toSlice | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} (h : p ≤ s.rawEndPos), s.posGE p h = String.Pos.ofToSlice (s.toSlice.posGE p ⋯) | true |
LaurentPolynomial.trunc | Mathlib.Algebra.Polynomial.Laurent | {R : Type u_1} → [inst : Semiring R] → LaurentPolynomial R →+ Polynomial R | true |
CategoryTheory.Oplax.OplaxTrans.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Hom η θ} →
{B' : Type u₁} ... | false |
_private.Mathlib.Order.Filter.FilterProduct.0.Filter.Germ.coe_lt._simp_1_4 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {f : Ultrafilter α} {p : α → Prop}, (∀ᶠ (x : α) in ↑f, ¬p x) = ¬∀ᶠ (x : α) in ↑f, p x | false |
CategoryTheory.mateEquiv_conjugateEquiv_vcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D}
{L₁ : Ca... | true |
NumberField.mixedEmbedding.unitSMul_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] (u : (NumberField.RingOfIntegers K)ˣ) (x : NumberField.mixedEmbedding.mixedSpace K),
u • x = (NumberField.mixedEmbedding K) ((algebraMap (NumberField.RingOfIntegers K) K) ↑u) * x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.