name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.Range.Polymorphic.BitVec.0.BitVec.instLawfulUpwardEnumerable._simp_4 | Init.Data.Range.Polymorphic.BitVec | ∀ {m n : ℕ}, m ≤ n → ∀ {x : BitVec m}, (x.toNat < 2 ^ n) = True | false |
Aesop.FVarIdSubst.ofFVarSubstIgnoringNonFVarIds | Aesop.RuleTac.FVarIdSubst | Lean.Meta.FVarSubst → Aesop.FVarIdSubst | true |
CategoryTheory.isIso_iff_nonzero | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasKernels C] {X Y : C} [CategoryTheory.Simple X] [CategoryTheory.Simple Y] (f : X ⟶ Y),
CategoryTheory.IsIso f ↔ f ≠ 0 | true |
FinBddDistLat.ofHom | Mathlib.Order.Category.FinBddDistLat | {X Y : Type u} →
[inst : DistribLattice X] →
[inst_1 : BoundedOrder X] →
[inst_2 : Fintype X] →
[inst_3 : DistribLattice Y] →
[inst_4 : BoundedOrder Y] →
[inst_5 : Fintype Y] → BoundedLatticeHom X Y → (FinBddDistLat.of X ⟶ FinBddDistLat.of Y) | true |
Order.Preimage.instIsStrictOrder | Mathlib.Order.RelClasses | ∀ {α : Type u} {β : Type v} {r : α → α → Prop} [IsStrictOrder α r] {f : β → α}, IsStrictOrder β (f ⁻¹'o r) | true |
AddAction.instDecidablePredMemAddSubmonoidStabilizerAddSubmonoidOfDecidableEq | Mathlib.GroupTheory.GroupAction.Defs | {M : Type u_1} →
{α : Type u_3} →
[inst : AddMonoid M] →
[inst_1 : AddAction M α] →
[DecidableEq α] → (a : α) → DecidablePred fun x => x ∈ AddAction.stabilizerAddSubmonoid M a | true |
Polynomial.instNormalizationMonoid._proof_10 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : NormalizationMonoid R] {a b : Polynomial R},
Polynomial.C ↑(normUnit (a * b).leadingCoeff)⁻¹ * Polynomial.C ↑(normUnit (a * b).leadingCoeff) = 1 | false |
Profinite.NobelingProof.isClosed_C0 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}},
IsClosed C → ∀ (ho : o < Ordinal.type fun x1 x2 => x1 < x2), IsClosed (Profinite.NobelingProof.C0 C ho) | true |
Std.DHashMap.Internal.Raw₀.map | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} → ((a : α) → β a → γ a) → Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α γ | true |
Fin.succAbove_of_lt_succ | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), p < i.succ → p.succAbove i = i.succ | true |
QuadraticAlgebra.instCommSemiring._proof_4 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : CommSemiring R] (x x_1 : QuadraticAlgebra R a b), x * x_1 = x_1 * x | false |
Part.mem_ofOption._simp_1 | Mathlib.Data.Part | ∀ {α : Type u_1} {a : α} {o : Option α}, (a ∈ ↑o) = (a ∈ o) | false |
Lean.Macro.Context.ctorIdx | Init.Prelude | Lean.Macro.Context → ℕ | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.span_singleton_mul_le_span_singleton_mul._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {I : Ideal R}, (x ∈ Ideal.span {y} * I) = ∃ z ∈ I, y * z = x | false |
CategoryTheory.Limits.WidePushoutShape.struct._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePushoutShape J} (j : J), Z = some j → some j = Z | false |
Lean.InductiveVal.mk.inj | Lean.Declaration | ∀ {toConstantVal : Lean.ConstantVal} {numParams numIndices : ℕ} {all ctors : List Lean.Name} {numNested : ℕ}
{isRec isUnsafe isReflexive : Bool} {toConstantVal_1 : Lean.ConstantVal} {numParams_1 numIndices_1 : ℕ}
{all_1 ctors_1 : List Lean.Name} {numNested_1 : ℕ} {isRec_1 isUnsafe_1 isReflexive_1 : Bool},
{ toCon... | true |
_private.Init.Data.String.Basic.0.String.copy_toSlice._simp_1_2 | Init.Data.String.Basic | ∀ {s : String}, s.utf8ByteSize = s.toByteArray.size | false |
CategoryTheory.ObjectProperty.small_unop_iff | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop ↔ CategoryTheory.ObjectProperty.Small.{w, v, u} P | true |
AlgCat.limitSemiring._aux_1 | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u_4} →
[inst : CommRing R] →
{J : Type u_3} →
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J (AlgCat R)) →
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections] →
(CategoryTheory.Limits.Types.Small.l... | false |
Finset.ruzsa_triangle_inequality_addNeg_add_add | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
(A + -C).card * B.card ≤ (A + B).card * (C + B).card | true |
NonUnitalCommCStarAlgebra.toNonUnitalNormedCommRing | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} → [self : NonUnitalCommCStarAlgebra A] → NonUnitalNormedCommRing A | true |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.foldlMAux.traverse | Lean.Data.PersistentHashMap | {m : Type w → Type w'} →
[Monad m] →
{σ : Type w} →
{α : Type u_1} →
{β : Type u_2} → (σ → α → β → m σ) → (keys : Array α) → (vals : Array β) → keys.size = vals.size → ℕ → σ → m σ | true |
Nat.add_mod_eq_add_mod_left | Init.Data.Nat.Lemmas | ∀ {a d b : ℕ} (c : ℕ), a % d = b % d → (c + a) % d = (c + b) % d | true |
WithConv.casesOn | Mathlib.Algebra.WithConv | {A : Sort u_1} →
{motive : WithConv A → Sort u} → (t : WithConv A) → ((ofConv : A) → motive (WithConv.toConv ofConv)) → motive t | false |
PresheafOfModules.Sheafify.smul_zero | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | true |
eval_det | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {n : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_3} [inst_2 : CommRing R]
(M : Matrix n n (Polynomial R)) (r : R),
Polynomial.eval r M.det = (Polynomial.eval ((Matrix.scalar n) r) (matPolyEquiv M)).det | true |
CategoryTheory.epi_comp_iff_of_isIso | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[CategoryTheory.IsIso g], CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g) ↔ CategoryTheory.Epi f | true |
IsOpen.tendstoLocallyUniformlyOn_iff_forall_tendsto | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
IsOpen s →
(TendstoLocallyUniformlyOn F f p s ↔
∀ x ∈ s, Filter.Tendsto (fun y => (f y.2, F y.1 y.2)) (p ×ˢ nhds x) (uniformity β)) | true |
RelIso.prodLexCongr._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {r₁ : α₁ → α₁ → Prop} {r₂ : α₂ → α₂ → Prop}
{s₁ : β₁ → β₁ → Prop} {s₂ : β₂ → β₂ → Prop} (e₁ : r₁ ≃r s₁) (e₂ : r₂ ≃r s₂) {a b : α₁ × α₂},
Prod.Lex s₁ s₂ ((e₁.prodCongr e₂.toEquiv) a) ((e₁.prodCongr e₂.toEquiv) b) ↔ Prod.Lex r₁ r₂ a b | false |
Lean.NamePart.num.sizeOf_spec | Lean.Data.NameTrie | ∀ (n : ℕ), sizeOf (Lean.NamePart.num n) = 1 + sizeOf n | true |
CategoryTheory.Limits.Types.isPullback_of_isPushout | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {X₁ X₂ X₃ X₄ : Type u} {t : X₁ ⟶ X₂} {r : X₂ ⟶ X₄} {l : X₁ ⟶ X₃} {b : X₃ ⟶ X₄},
CategoryTheory.IsPushout t l r b → Function.Injective t → CategoryTheory.IsPullback t l r b | true |
isRelLowerSet_empty._simp_1 | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α], IsRelLowerSet ∅ P = True | false |
sectionOfRetractionKerToTensorAux.congr_simp | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] (l l_1 : TensorProduct P S Ω[P⁄R] →ₗ[P] ↥(RingHom.ker (algebraMap P S)))
(e_l : l = l_1) (hl : l ∘ₗ KaehlerDifferential.kerToTensor R P S = LinearMap.id) (σ σ_... | true |
nnnorm_cfcₙHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : outParam (A → Prop)} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : StarRing A] [inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A]
[inst_6 : NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p] (a : A)
(f : ContinuousM... | true |
Set.instFintypeIcc | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrder α] → (a b : α) → Fintype ↑(Set.Icc a b) | true |
OptionT.instMonadLift | Init.Control.Option | {m : Type u → Type v} → [Monad m] → MonadLift m (OptionT m) | true |
Batteries.Tactic.PrintPrefixConfig.ctorIdx | Batteries.Tactic.PrintPrefix | Batteries.Tactic.PrintPrefixConfig → ℕ | false |
CategoryTheory.Functor.preimageIso_mapIso | 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) {X Y : C} [inst_2 : F.Full] [inst_3 : F.Faithful] (f : X ≅ Y),
F.preimageIso (F.mapIso f) = f | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Limits_ExactFunctor___unexpand_CategoryTheory_ExactFunctor_1 | Mathlib.CategoryTheory.Limits.ExactFunctor | Lean.PrettyPrinter.Unexpander | false |
Nat.ofNat_lt_cast | Mathlib.Data.Nat.Cast.Order.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ} [inst_5 : m.AtLeastTwo], OfNat.ofNat m < ↑n ↔ OfNat.ofNat m < n | true |
IsDedekindDomain.selmerGroup.fromUnit | Mathlib.RingTheory.DedekindDomain.SelmerGroup | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
{K : Type v} →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → {n : ℕ} → Rˣ →* ↥IsDedekindDomain.selmerGroup | true |
instCommRingFreeCommRing._aux_1 | Mathlib.RingTheory.FreeCommRing | (α : Type u_1) → FreeCommRing α → FreeCommRing α → FreeCommRing α | false |
Lean.Compiler.LCNF.ToMonoM.State.rec | Lean.Compiler.LCNF.ToMono | {motive : Lean.Compiler.LCNF.ToMonoM.State → Sort u} →
((typeParams : Lean.FVarIdHashSet) → motive { typeParams := typeParams }) →
(t : Lean.Compiler.LCNF.ToMonoM.State) → motive t | false |
_private.Init.Data.Nat.Fold.0.Nat.fold_congr._proof_1 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, n = m → ∀ i < m, ¬i < n → False | false |
Fintype.sum_subtype_add_sum_subtype | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} {ι : Type u_7} [inst : Fintype ι] [inst_1 : AddCommMonoid M] (p : ι → Prop) (f : ι → M)
[inst_2 : DecidablePred p], ∑ i, f ↑i + ∑ i, f ↑i = ∑ i, f i | true |
Finsupp.embDomain_comapDomain | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] {f : α ↪ β} {g : β →₀ M},
↑g.support ⊆ Set.range ⇑f → Finsupp.embDomain f (Finsupp.comapDomain (⇑f) g ⋯) = g | true |
Set.MapsTo.subset_preimage | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.MapsTo f s t → s ⊆ f ⁻¹' t | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.Strictness.toPositive.match_1 | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
{e : Q(«$α»)} →
(motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u_1) →
(x : Mathlib.Meta.Positivity.Strictness zα pα e) →
((pf : Q(0 < «$e»)) → motive (Mathlib.Met... | false |
Setoid.mkClasses_classes | Mathlib.Data.Setoid.Partition | ∀ {α : Type u_1} (r : Setoid α), Setoid.mkClasses r.classes ⋯ = r | true |
Lean.Elab.Tactic.Omega.Problem.addInequality | Lean.Elab.Tactic.Omega.Core | Lean.Elab.Tactic.Omega.Problem →
ℤ → Lean.Omega.Coeffs → Option Lean.Elab.Tactic.Omega.Proof → Lean.Elab.Tactic.Omega.Problem | true |
Sym.mem_mk | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (s : Multiset α) (h : s.card = n), a ∈ Sym.mk s h ↔ a ∈ s | true |
Std.Sat.AIG.RefVec.cast'.eq_1 | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α} (s : aig1.RefVec len)
(h :
(∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig1.decls.size) →
∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig2.decls.size),
s.cast' h = { refs := s.refs, hrefs := ⋯ } | true |
_private.Init.Data.SInt.Lemmas.0.Int32.toISize_ne_minValue._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x = y) = (x.toInt = y.toInt) | false |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.mkBoxedVersion.match_1 | Lean.Compiler.LCNF.ExplicitBoxing | (motive :
Option
(Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure ×
Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) →
Sort u_1) →
(x :
Option
(Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure ×
Subarray (Lean.Compiler.LCNF.Pa... | false |
NumberField.IsCMField.mem_realUnits_iff | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] (u : (NumberField.RingOfIntegers K)ˣ),
u ∈ NumberField.IsCMField.realUnits K ↔
∃ v,
(algebraMap (NumberField.RingOfIntegers ↥(NumberField.maximalRealSubfield K)) (NumberField.RingOfIntegers K)) ↑v =
↑u | true |
MonoidHom.fiberEquivKerOfSurjective._proof_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_2} [inst : Group α] {H : Type u_1} [inst_1 : Group H] {f : α →* H} (hf : Function.Surjective ⇑f) (h : H),
f ⋯.choose = h | false |
Std.TreeMap.Raw.getElem!_union_of_not_mem_right | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst : Inhabited β], k ∉ t₂ → (t₁ ∪ t₂)[k]! = t₁[k]! | true |
Subarray.get! | Init.Data.Array.Subarray | {α : Type u_1} → [Inhabited α] → Subarray α → ℕ → α | true |
Mathlib.Tactic.ITauto.IProp.ctorElim | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.IProp → Sort u} →
(ctorIdx : ℕ) →
(t : Mathlib.Tactic.ITauto.IProp) →
ctorIdx = t.ctorIdx → Mathlib.Tactic.ITauto.IProp.ctorElimType ctorIdx → motive t | false |
Ordering | Init.Data.Ord.Basic | Type | true |
List.Cursor | Std.Do.Triple.SpecLemmas | {α : Type u} → List α → Type u | true |
Stream'.WSeq.drop.aux_none | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (n : ℕ), Stream'.WSeq.drop.aux n none = Computation.pure none | true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.Seq.BisimO.match_1.splitter | Mathlib.Data.WSeq.Basic | {α : Type u_1} →
(motive : Option (Stream'.Seq1 α) → Option (Stream'.Seq1 α) → Sort u_2) →
(x x_1 : Option (Stream'.Seq1 α)) →
(Unit → motive none none) →
((a : α) → (s : Stream'.Seq α) → (a' : α) → (s' : Stream'.Seq α) → motive (some (a, s)) (some (a', s'))) →
((x x_2 : Option (Stream'.Se... | true |
Std.Rci.rec | Init.Data.Range.Polymorphic.PRange | {α : Type u} → {motive : Std.Rci α → Sort u_1} → ((lower : α) → motive lower...*) → (t : Std.Rci α) → motive t | false |
CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.instRingEmbeddingRing._aux_4 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.SmallCategory D] →
(F : CategoryTheory.Functor D Cᵒᵖ) →
[inst_2 : CategoryTheory.Abelian C] →
[inst_3 : CategoryTheory.IsGrothendieckAbelian.{u_1, u_1, u_2} C] →
... | false |
MultilinearMap.freeFinsuppEquiv._proof_4 | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
supIrred_ofDual | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : αᵒᵈ}, SupIrred (OrderDual.ofDual a) ↔ InfIrred a | true |
NonUnitalSeminormedRing.rec | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
{motive : NonUnitalSeminormedRing α → Sort u} →
([toNorm : Norm α] →
[toNonUnitalRing : NonUnitalRing α] →
[toPseudoMetricSpace : PseudoMetricSpace α] →
(dist_eq : ∀ (x y : α), dist x y = ‖-x + y‖) →
(norm_mul_le : ∀ (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖) →
... | false |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.isUnit_resultant_iff_isCoprime.match_1_4 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] {f g : Polynomial R} (motive : IsCoprime f g → Prop) (h : IsCoprime f g),
(∀ (a b : Polynomial R) (e : a * f + b * g = 1), motive ⋯) → motive h | false |
Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.axiom.formatter_105 | Lean.Parser.Command | IO Unit | false |
AddCommGrpCat.ofHom_hom | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddCommGrpCat} (f : X ⟶ Y), AddCommGrpCat.ofHom (AddCommGrpCat.Hom.hom f) = f | true |
CategoryTheory.Grothendieck.functorFrom_obj | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{E : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} E] (fib : (c : C) → CategoryTheory.Functor (↑(F.obj c)) E)
(hom : {c c' : C} → (f : c ⟶ c') → fib c ⟶ (F.map f).toFunctor.comp (fib c'))
(hom_id : ... | true |
CategoryTheory.Free.of | Mathlib.Algebra.Category.ModuleCat.Adjunctions | (R : Type u_1) → {C : Type u} → C → CategoryTheory.Free R C | true |
Mathlib.Tactic.Widget.StringDiagram.IdNode | Mathlib.Tactic.Widget.StringDiagram | Type | true |
Topology.IsConstructible.preimage_of_isOpenEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsOpenEmbedding f → Topology.IsConstructible s → Topology.IsConstructible (f ⁻¹' s) | true |
Hashable.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Sort u} →
{t : Hashable α} → {α' : Sort u} → {t' : Hashable α'} → α = α' → t ≍ t' → Hashable.noConfusionType P t t' | false |
ProbabilityTheory.HasGaussianLaw.toLp_prodMk | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {F : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E]
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F] [inst_6 : MeasurableSpace F] [BorelSpace F... | true |
Std.ExtTreeMap.minKey?_insertIfNew_le_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {kmi : α}, (t.insertIfNew k v).minKey?.get ⋯ = kmi → (cmp kmi k).isLE = true | true |
convexIndependent_iff_notMem_convexHull_diff | Mathlib.Analysis.Convex.Independent | ∀ {𝕜 : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] {p : ι → E},
ConvexIndependent 𝕜 p ↔ ∀ (i : ι) (s : Set ι), p i ∉ (convexHull 𝕜) (p '' (s \ {i})) | true |
Qq.QuotedDefEq.unsafeIntro | Qq.Typ | ∀ {u : Lean.Level} {α : Q(Sort u)} {lhs rhs : Q(«$α»)}, «$lhs» =Q «$rhs» | true |
_private.Batteries.Data.Char.AsciiCasing.0.Char.not_isLower_of_isUpper._simp_1_2 | Batteries.Data.Char.AsciiCasing | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
TopCat.isInitialPEmpty._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ (X : TopCat) (f : TopCat.of PEmpty.{u_1 + 1} ⟶ X), f = default | false |
Nat.boddDiv2 | Mathlib.Data.Nat.Bits | ℕ → Bool × ℕ | true |
CategoryTheory.Functor.closedIhom_map_app | Mathlib.CategoryTheory.Monoidal.Closed.FunctorCategory.Groupoid | ∀ {D : Type u} {C : Type u_1} [inst : CategoryTheory.Groupoid D] [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
(F : CategoryTheory.Functor D C) {X Y : CategoryTheory.Functor D C} (g : X ⟶ Y) (X_1 : D),
(F.closedIhom.map g).a... | true |
RelSeries.subsingleton_of_length_eq_zero | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r}, s.length = 0 → {x | x ∈ s}.Subsingleton | true |
_private.Mathlib.RepresentationTheory.Rep.Iso.0.Rep.instHasBinaryBiproducts._simp_3 | Mathlib.RepresentationTheory.Rep.Iso | ∀ {k : Type u} {G : Type v} [inst : Semiring k] [inst_1 : Monoid G] {X Y : Type w} [inst_2 : AddCommGroup X]
[inst_3 : AddCommGroup Y] [inst_4 : Module k X] [inst_5 : Module k Y] {ρ : Representation k G X}
{σ : Representation k G Y} (f g : ρ.IntertwiningMap σ), Rep.ofHom f + Rep.ofHom g = Rep.ofHom (f + g) | false |
MDifferentiableAt.prodMap' | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
Equiv.nonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalNonAssocSemiring β] (x y : α),
e (e.symm (e x + e y)) = e x + e y | false |
Filter.bot_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {g : Filter α}, ⊥ / g = ⊥ | true |
Real.Angle.two_nsmul_eq_pi_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, 2 • θ = ↑Real.pi ↔ θ = ↑(Real.pi / 2) ∨ θ = ↑(-Real.pi / 2) | true |
BitVec.ofBoolListLE._sunfold | Init.Data.BitVec.Basic | (bs : List Bool) → BitVec bs.length | false |
Plausible.Gen.listOf | Plausible.Gen | {α : Type u} → Plausible.Gen α → Plausible.Gen (List α) | true |
IsTrans.comap | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {r : β → β → Prop}, IsTrans β r → ∀ (f : α → β), IsTrans α (Function.onFun r f) | true |
Order.succ_eq_succ_iff._simp_2 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α} [NoMaxOrder α],
(Order.succ a = Order.succ b) = (a = b) | false |
RatFunc.algEquivOfTranscendental._proof_11 | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (f : L),
IsScalarTower K ↥K[f] ↥K⟮f⟯ | false |
MeasureTheory.meas_le_ae_eq_meas_lt | Mathlib.MeasureTheory.Integral.Layercake | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {R : Type u_3} [inst_1 : LinearOrder R]
[inst_2 : MeasurableSpace R] (ν : MeasureTheory.Measure R) [MeasureTheory.NoAtoms ν] (g : α → R),
(fun t => μ {a | t ≤ g a}) =ᵐ[ν] fun t => μ {a | t < g a} | true |
AddConstEquiv.instEquivLike._proof_2 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H} (f : AddConstEquiv G H a b),
Function.RightInverse f.invFun f.toFun | false |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.StructInstState.mk.noConfusion | Lean.Elab.StructInst | {P : Sort u} →
{type : Lean.Expr} →
{structNameSet : Lean.NameSet} →
{fieldMap : Lean.NameMap Lean.Expr} →
{fields : Array Lean.Expr} →
{instMVars : Array Lean.MVarId} →
{liftedFVars : Array Lean.Expr} →
{liftedFVarRemap : Lean.FVarIdMap Lean.FVarId} →
... | false |
PNat.gcdB' | Mathlib.Data.PNat.Xgcd | ℕ+ → ℕ+ → ℕ+ | true |
retractionKerCotangentToTensorEquivSection.match_3 | Mathlib.RingTheory.Smooth.Kaehler | {R : Type u_3} →
{P : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing P] →
[inst_2 : CommRing S] →
[inst_3 : Algebra R P] →
[inst_4 : Algebra P S] →
let P' := P ⧸ RingHom.ker (algebraMap P S) ^ 2;
(motive : { l... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.