name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
DirectSum.GSemiring.natCast_succ | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} {A : ι → Type u_2} {inst : AddMonoid ι} {inst_1 : (i : ι) → AddCommMonoid (A i)}
[self : DirectSum.GSemiring A] (n : ℕ),
DirectSum.GSemiring.natCast (n + 1) = DirectSum.GSemiring.natCast n + GradedMonoid.GOne.one | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | true |
Pi.isAtom_iff | Mathlib.Order.Atoms | ∀ {ι : Type u_4} {π : ι → Type u} {f : (i : ι) → π i} [inst : (i : ι) → PartialOrder (π i)]
[inst_1 : (i : ι) → OrderBot (π i)], IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ (j : ι), j ≠ i → f j = ⊥ | true |
AlgebraicGeometry.StructureSheaf.isLocalizedModule_toPushforwardStalkAlgHom_aux | Mathlib.AlgebraicGeometry.Spec | ∀ (R S : CommRingCat) (p : PrimeSpectrum ↑R) [inst : Algebra ↑R ↑S]
(y :
↑(((TopCat.Presheaf.pushforward CommRingCat
(AlgebraicGeometry.Spec.topMap (CommRingCat.ofHom (algebraMap ↑R ↑S)))).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p)),
∃ x, x.2 • y = (Algebrai... | true |
UInt32.ne_of_toBitVec_ne | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toBitVec ≠ b.toBitVec → a ≠ b | true |
HasFPowerSeriesOnBall.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {r : ENNReal} {f : E → F} {x : E} [CompleteSpace F],
HasFPowerSeriesOnBall f ... | true |
CategoryTheory.Bicategory.precomp | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → {a b : B} → (c : B) → (a ⟶ b) → CategoryTheory.Functor (b ⟶ c) (a ⟶ c) | true |
Padic.padicNormE.image | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q : ℚ_[p]}, q ≠ 0 → ∃ n, ‖q‖ = ↑(↑p ^ (-n)) | true |
Lean.Grind.AC.Context.rec | Init.Grind.AC | {α : Sort u} →
{motive : Lean.Grind.AC.Context α → Sort u_1} →
((vars : Lean.RArray (PLift α)) → (op : α → α → α) → motive { vars := vars, op := op }) →
(t : Lean.Grind.AC.Context α) → motive t | false |
Mathlib.Tactic.TermCongr.mkIffForExpectedType | Mathlib.Tactic.TermCongr | Option Lean.Expr → Lean.MetaM Lean.Expr | true |
SchwartzMap.ctorIdx | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | {E : Type u_5} →
{F : Type u_6} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} → {inst_2 : NormedAddCommGroup F} → {inst_3 : NormedSpace ℝ F} → SchwartzMap E F → ℕ | false |
_private.Mathlib.Algebra.ContinuedFractions.TerminatedStable.0.GenContFract.contsAux.match_1.splitter | Mathlib.Algebra.ContinuedFractions.TerminatedStable | {K : Type u_1} →
(motive : Option (GenContFract.Pair K) → Sort u_2) →
(x : Option (GenContFract.Pair K)) →
(Unit → motive none) → ((gp : GenContFract.Pair K) → motive (some gp)) → motive x | true |
instCompleteLatticeUniformSpace._proof_6 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} (a x x_1 : UniformSpace α), a ≤ x → a ≤ x_1 → UniformSpace.uniformity ≤ uniformity α | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_364 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length] + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
... | false |
Std.HashSet.filter_equiv_self_iff | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {f : α → Bool},
(Std.HashSet.filter f m).Equiv m ↔ ∀ (k : α) (h : k ∈ m), f (m.get k h) = true | true |
Subgroup.normalCore_le | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.normalCore ≤ H | true |
lt_of_mul_lt_mul_of_nonneg_right | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosReflectLT α],
b * a < c * a → 0 ≤ a → b < c | true |
PiTensorProduct.map₂_tprod_tprod | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_11} {t' : ι → Type u_12} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] [inst_5 : (i : ι) → AddCommMonoid (t' i)] [ins... | true |
CategoryTheory.subcanonical_typesGrothendieckTopology | Mathlib.CategoryTheory.Sites.Types | CategoryTheory.typesGrothendieckTopology.Subcanonical | true |
CategoryTheory.Limits.CompleteLattice.finiteLimitCone_isLimit_lift | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u} {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeInf α] [inst_3 : OrderTop α] (F : CategoryTheory.Functor J α) (s : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.CompleteLattice.finiteLimitCone F).isLimit.lift s = CategoryTheory... | true |
CauSeq.coe_smul._simp_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] {G : Type u_3} [inst_5 : SMul G β]
[inst_6 : IsScalarTower G β β] (a : G) (f : CauSeq β abv), a • ↑f = ↑(a • f) | false |
StrongDual.extendRCLikeₗ._proof_7 | Mathlib.Analysis.RCLike.Extend | ContinuousConstSMul ℝ ℝ | false |
CategoryTheory.Limits.Cowedge.ext._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.End | Lean.Syntax | false |
TensorProduct.directSum._proof_11 | Mathlib.LinearAlgebra.DirectSum.TensorProduct | ∀ (R : Type u_6) [inst : CommSemiring R] (S : Type u_5) [inst_1 : Semiring S] [inst_2 : Algebra R S] {ι₁ : Type u_1}
{ι₂ : Type u_3} [inst_3 : DecidableEq ι₁] [inst_4 : DecidableEq ι₂] (M₁ : ι₁ → Type u_2) (M₂ : ι₂ → Type u_4)
[inst_5 : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)] [inst_6 : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)]... | false |
Fin.succAbove_ne_zero_zero | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} [inst : NeZero n] {a : Fin (n + 1)}, a ≠ 0 → a.succAbove 0 = 0 | true |
CategoryTheory.Limits.biconeIsBilimitOfColimitCoconeOfIsColimit._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
{f : J → C} {t : CategoryTheory.Limits.Cocone (CategoryTheory.Discrete.functor f)}
(ht : CategoryTheory.Limits.IsColimit t) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (t.ι... | false |
Std.Iter.Total.ctorIdx | Init.Data.Iterators.Consumers.Total | {α β : Type w} → Std.Iter.Total β → ℕ | false |
LieModule.maxTrivLinearMapEquivLieModuleHom._proof_10 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]
[ins... | false |
SubringClass.toNonAssocRing | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} →
{S : Type v} → [inst : NonAssocRing R] → [inst_1 : SetLike S R] → [hSR : SubringClass S R] → (s : S) → NonAssocRing ↥s | true |
Lean.Grind.ToInt.Zero.casesOn | Init.Grind.ToInt | {α : Type u} →
[inst : Zero α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.Zero α I → Sort u_1} →
(t : Lean.Grind.ToInt.Zero α I) → ((toInt_zero : ↑0 = 0) → motive ⋯) → motive t | false |
ModelPi | Mathlib.Geometry.Manifold.ChartedSpace | {ι : Type u_5} → (ι → Type u_6) → Type (max u_5 u_6) | true |
CategoryTheory.Square.commSq | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C),
CategoryTheory.CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄ | true |
LieSubalgebra.coe_sInf | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(S : Set (LieSubalgebra R L)), ↑(sInf S) = ⋂ s ∈ S, ↑s | true |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.CongrResult.mk'.toEqPf | Mathlib.Tactic.TermCongr | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
Aesop.ForwardHypData.noConfusion | Aesop.RuleTac.Forward.Basic | {P : Sort u} → {t t' : Aesop.ForwardHypData} → t = t' → Aesop.ForwardHypData.noConfusionType P t t' | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape.0.CategoryTheory.TransfiniteCompositionOfShape.map._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
_private.Lean.Compiler.LCNF.Level.0.Lean.Compiler.LCNF.NormLevelParam.normLevel.match_1 | Lean.Compiler.LCNF.Level | (motive : Lean.Compiler.LCNF.NormLevelParam.State → Sort u_1) →
(x : Lean.Compiler.LCNF.NormLevelParam.State) →
((nextIdx : ℕ) →
(map : Std.HashMap Lean.Name Lean.Level) →
(paramNames : Array Lean.Name) → motive { nextIdx := nextIdx, map := map, paramNames := paramNames }) →
motive x | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Comma.0.CategoryTheory.MorphismProperty.instFaithfulOverTopOverForget._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P : CategoryTheory.MorphismProperty T) (X : T),
(CategoryTheory.MorphismProperty.Over.forget P ⊤ X).Faithful | false |
Lean.Lsp.SignatureHelpTriggerKind.contentChange.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SignatureHelpTriggerKind → Sort u} →
(t : Lean.Lsp.SignatureHelpTriggerKind) →
t.ctorIdx = 2 → motive Lean.Lsp.SignatureHelpTriggerKind.contentChange → motive t | false |
Matrix.linearIndependent_rows_of_invertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} [inst : DecidableEq m] {K : Type u_3} [inst_1 : Field K] [inst_2 : Fintype m] (A : Matrix m m K)
[Invertible A], LinearIndependent K A.row | true |
Lean.Grind.instOfNatInt16SintOfNatNat | Init.GrindInstances.ToInt | Lean.Grind.ToInt.OfNat Int16 (Lean.Grind.IntInterval.sint 16) | true |
Nat.bit_lt_bit | Mathlib.Data.Nat.Bits | ∀ {m n : ℕ} (a b : Bool), m < n → Nat.bit a m < Nat.bit b n | true |
CategoryTheory.SimplicialThickening.Path.rec | Mathlib.AlgebraicTopology.SimplicialNerve | {J : Type u_1} →
[inst : LinearOrder J] →
{i j : J} →
{motive : CategoryTheory.SimplicialThickening.Path i j → Sort u} →
((I : Set J) →
(left : i ∈ I) →
(right : j ∈ I) →
(left_le : ∀ k ∈ I, i ≤ k) →
(le_right : ∀ k ∈ I, k ≤ j) →
... | false |
Int32.reduceOfInt._regBuiltin.Int32.reduceOfInt.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2667021113._hygCtx._hyg.376 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
Lean.Compiler.LCNF.FixedParams.Context.recOn | Lean.Compiler.LCNF.FixedParams | {motive : Lean.Compiler.LCNF.FixedParams.Context → Sort u} →
(t : Lean.Compiler.LCNF.FixedParams.Context) →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(main : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
(assignment : Lean.FVarIdMap Lean.Compiler.LCN... | false |
CategoryTheory.Functor.preservesLimit_cospan_of_mem_presieve | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {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 : CategoryTheory.Functor C D} {X : C}
(R : CategoryTheory.Presieve X) [self : F.PreservesPairwisePullbacks R] ⦃Y Z : C⦄ ⦃f : Y ⟶ X⦄ ⦃g : Z ⟶ X⦄,
R f → R g → CategoryTheory.Limits.Preser... | true |
MonomialOrder.lex._proof_3 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} (a b : σ →₀ ℕ), toLex (a + b) = toLex a + toLex b | false |
CategoryTheory.Arrow.isoOfNatIso._proof_2 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C D} (e : F ≅ G)
(f : CategoryTheory.Arrow C),
CategoryTheory.CategoryStruct.comp (e.app f.left).hom (G.mapArrow.obj f).hom =
CategoryTheory.CategoryStruc... | false |
ValuationSubring.mem_ofSubring._simp_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (R : Subring K) (hR : ∀ (x : K), x ∈ R ∨ x⁻¹ ∈ R) (x : K),
(x ∈ ValuationSubring.ofSubring R hR) = (x ∈ R) | false |
TensorProduct.AlgebraTensorModule.lTensor_comp | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {Q : Type uQ} {Q' : Type uQ'} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 ... | true |
DMatrix.instUnique | Mathlib.Data.Matrix.DMatrix | {m : Type u_1} → {n : Type u_2} → {α : m → n → Type v} → [(i : m) → (j : n) → Unique (α i j)] → Unique (DMatrix m n α) | true |
Parser.Attr.qify_simps | Mathlib.Tactic.Attr.Register | Lean.ParserDescr | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.forM_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
SimplicialObject.Splitting.cofan_inj_id | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C}
(s : SimplicialObject.Splitting X) (n : ℕ),
(s.cofan (Opposite.op (SimplexCategory.mk n))).inj
(SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk n))) =
s.ι n | true |
StrictMonoOn.union | Mathlib.Order.Monotone.Union | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α} {c : α},
StrictMonoOn f s → StrictMonoOn f t → IsGreatest s c → IsLeast t c → StrictMonoOn f (s ∪ t) | true |
Polynomial.isMonicOfDegree_X_add_one | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Semiring R] [Nontrivial R] (r : R), (Polynomial.X + Polynomial.C r).IsMonicOfDegree 1 | true |
Lean.Meta.TransparencyMode.noConfusion | Init.MetaTypes | {P : Sort v✝} → {x y : Lean.Meta.TransparencyMode} → x = y → Lean.Meta.TransparencyMode.noConfusionType P x y | false |
FinBoolAlg.noConfusion | Mathlib.Order.Category.FinBoolAlg | {P : Sort u} → {t t' : FinBoolAlg} → t = t' → FinBoolAlg.noConfusionType P t t' | false |
CategoryTheory.ShortComplex.π_moduleCatCyclesIso_hom_assoc_apply | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)) {Z : ModuleCat R}
(h : S.moduleCatLeftHomologyData.H ⟶ Z) (x : ↑S.cycles),
(CategoryTheory.ConcreteCategory.hom h)
((CategoryTheory.ConcreteCategory.hom S.moduleCatHomologyIso.hom)
((CategoryTheory.ConcreteCategory.hom S.ho... | true |
Plausible.InjectiveFunction.shrink._proof_5 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type} (xs' ys' : List α),
xs'.Perm ys' →
xs'.length ≤ ys'.length →
ys'.length ≤ xs'.length →
(List.map Sigma.fst (List.map Prod.toSigma (xs'.zip ys'))).Perm
(List.map Sigma.snd (List.map Prod.toSigma (xs'.zip ys'))) | false |
CategoryTheory.Comonad.forget_creates_limits_of_comonad_preserves | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} [CategoryTheory.Limits.PreservesLimitsOfShape J T.toFunctor]
(D : CategoryTheory.Functor J T.Coalgebra) [CategoryTheory.Limits.HasLimit (D.comp T.forget)],
CategoryTh... | true |
List.SortedLT.map_toDual | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, (List.map (⇑OrderDual.toDual) l).SortedLT → l.SortedGT | true |
Nat.findGreatest_eq_zero_iff | Mathlib.Data.Nat.Find | ∀ {k : ℕ} {P : ℕ → Prop} [inst : DecidablePred P], Nat.findGreatest P k = 0 ↔ ∀ ⦃n : ℕ⦄, 0 < n → n ≤ k → ¬P n | true |
CentroidHom.centerToCentroidCenter | Mathlib.Algebra.Ring.CentroidHom | {α : Type u_5} →
[inst : NonUnitalNonAssocSemiring α] → ↥(NonUnitalSubsemiring.center α) →ₙ+* ↥(Subsemiring.center (CentroidHom α)) | true |
LieEquiv.ofSubalgebras_apply | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (L₁' : LieSubalgebra R L₁) (L₂' : LieSubalgebra R L₂)
(e : L₁ ≃ₗ⁅R⁆ L₂) (h : LieSubalgebra.map e.toLieHom L₁' = L₂') (x : ↥L₁'),
↑((LieEquiv.ofSubalgebra... | true |
_private.Std.Data.DHashMap.Internal.Raw.0.Std.DHashMap.Raw.diff.eq_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Raw α β),
m₁.diff m₂ =
if h₁ : 0 < m₁.buckets.size then
if h₂ : 0 < m₂.buckets.size then ↑(Std.DHashMap.Internal.Raw₀.diff ⟨m₁, h₁⟩ ⟨m₂, h₂⟩) else m₁
else m₂ | true |
CategoryTheory.isFinitelyPresentable_iff_preservesFilteredColimits | Mathlib.CategoryTheory.Presentable.Finite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C},
CategoryTheory.IsFinitelyPresentable X ↔
CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.coyoneda.obj (Opposite.op X)) | true |
isPreirreducible_iff_isClosed_union_isClosed | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsPreirreducible s ↔ ∀ (z₁ z₂ : Set X), IsClosed z₁ → IsClosed z₂ → s ⊆ z₁ ∪ z₂ → s ⊆ z₁ ∨ s ⊆ z₂ | true |
IntermediateField.LinearDisjoint.symm | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.LinearDisjoint ↥B → B.LinearDisjoint ↥A | true |
instModuleTensorProductMop._proof_1 | Mathlib.Algebra.Azumaya.Defs | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
IsScalarTower R Aᵐᵒᵖ A | false |
CategoryTheory.Limits.ChosenPullback₃.w₁_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ ... | true |
List.find?_append | Init.Data.List.Impl | ∀ {α : Type u_1} {p : α → Bool} {xs ys : List α}, List.find? p (xs ++ ys) = (List.find? p xs).or (List.find? p ys) | true |
StandardSubspace.mk._flat_ctor | Mathlib.Analysis.InnerProductSpace.StandardSubspace | {H : Type u_1} →
[inst : NormedAddCommGroup H] →
[inst_1 : InnerProductSpace ℂ H] →
(toClosedSubmodule : ClosedSubmodule ℝ H) →
toClosedSubmodule ⊓ toClosedSubmodule.mulI = ⊥ →
toClosedSubmodule ⊔ toClosedSubmodule.mulI = ⊤ → StandardSubspace H | false |
IntermediateField.instAlgebraSubtypeMemAdjoinSingletonSetCoeRingHomAlgebraMap._proof_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {A : Type u_2} {B : Type u_1} [inst : Field A] [inst_1 : Field B] [inst_2 : Algebra A B],
SubsemiringClass (IntermediateField A B) B | false |
CategoryTheory.Bicategory.Equivalence.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : B} {hom : a ⟶ b} {inv : b ⟶ a}
{unit : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp hom inv}
{counit : CategoryTheory.CategoryStruct.comp inv hom ≅ CategoryTheory.CategoryStruct.id b}
{left_triangle :
autoParam
(Catego... | true |
Ideal.IsTwoSided.mul_one | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I : Ideal R} [I.IsTwoSided], I * 1 = I | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_spanning_iff_of_subsingleton._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {α : Type u_2} (M : Matroid α) (S : Set α), M.Spanning S = (M.closure S = M.E ∧ S ⊆ M.E) | false |
SheafOfModules.hasLimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Sheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
(R : CategoryTheory.Sheaf J RingCat),
CategoryTheory.Limits.HasLimitsOfSize.{v₂, v, max u₁ v, max (max (max (v + 1) u) u₁) v₁} (SheafOfModules R) | true |
MeasureTheory.Lp.constₗ | Mathlib.MeasureTheory.Function.LpSpace.Indicator | {α : Type u_1} →
{E : Type u_2} →
{m : MeasurableSpace α} →
(p : ENNReal) →
(μ : MeasureTheory.Measure α) →
[inst : NormedAddCommGroup E] →
[MeasureTheory.IsFiniteMeasure μ] →
(𝕜 : Type u_3) →
[inst_2 : NormedRing 𝕜] →
[inst_3 :... | true |
LinearPMap | Mathlib.LinearAlgebra.LinearPMap | (R : Type u) →
[inst : Ring R] →
(E : Type v) →
[inst_1 : AddCommGroup E] →
[Module R E] → (F : Type w) → [inst_3 : AddCommGroup F] → [Module R F] → Type (max v w) | true |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.CollectState.collectedThms._default | Lean.Meta.Tactic.Grind.EMatchAction | Std.HashSet (Lean.Meta.Grind.Origin × Lean.Meta.Grind.EMatchTheoremKind) | false |
ProbabilityTheory.«_aux_Mathlib_Probability_ConditionalProbability___macroRules_ProbabilityTheory_term__[|_]_1» | Mathlib.Probability.ConditionalProbability | Lean.Macro | false |
Associated.of_pow_associated_of_prime' | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {p₁ p₂ : M} {k₁ k₂ : ℕ},
Prime p₁ → Prime p₂ → 0 < k₂ → Associated (p₁ ^ k₁) (p₂ ^ k₂) → Associated p₁ p₂ | true |
MeasureTheory.Filtration.natural | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
{ι : Type u_2} →
{m : MeasurableSpace Ω} →
{β : ι → Type u_3} →
[inst : (i : ι) → TopologicalSpace (β i)] →
[∀ (i : ι), TopologicalSpace.MetrizableSpace (β i)] →
[mβ : (i : ι) → MeasurableSpace (β i)] →
[∀ (i : ι), BorelSpace (β i)] →
... | true |
CategoryTheory.Limits.Cocones.postcomposeId | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
CategoryTheory.Limits.Cocone.precompose (CategoryTheory.CategoryStruct.id F) ≅
CategoryTheory.Functor.id (CategoryThe... | true |
List.toChunks.go | Batteries.Data.List.Basic | {α : Type u_1} → ℕ → List α → Array α → Array (List α) → List (List α) | true |
LightCondensed.instMonoidalLightCondSetLightCondModFree._aux_10 | Mathlib.Condensed.Light.Monoidal | (R : Type u_1) →
[inst : CommRing R] →
(LightCondensed.free R).obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit LightCondSet) ⟶
CategoryTheory.MonoidalCategoryStruct.tensorUnit (LightCondMod R) | false |
Path.extend | Mathlib.Topology.Path | {X : Type u_1} → [inst : TopologicalSpace X] → {x y : X} → Path x y → C(ℝ, X) | true |
Lean.Lsp.PrepareRenameParams._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.PrepareRenameParams → ℕ | false |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.coeff.match_1.eq_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (motive : SkewMonoidAlgebra k G → Sort u_3) (p : G →₀ k)
(h_1 : (p : G →₀ k) → motive { toFinsupp := p }),
(match { toFinsupp := p } with
| { toFinsupp := p } => h_1 p) =
h_1 p | true |
CategoryTheory.Limits.kernelFactorThruImage.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] [inst_3 : CategoryTheory.Limits.HasImage f]
[inst_4 : CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.factorThruImage f)],
Category... | true |
Std.Tactic.BVDecide.BVExpr.Cache.insert._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} {w : ℕ} (expr : Std.Tactic.BVDecide.BVExpr w) (refs : aig.RefVec w)
(map : Std.DHashMap Std.Tactic.BVDecide.BVExpr.Cache.Key fun k => Vector Std.Sat.AIG.Fanin k.w),
(∀ {i : ℕ} (k : Std.Tactic.BVDecide.BVExpr.Cache.Key) (h1 : k ∈ map) (h2 : i < k.w),
(map.get k h... | false |
_private.Mathlib.RingTheory.ClassGroup.0.ClassGroup.mk_eq_one_of_coe_ideal._proof_1_1 | Mathlib.RingTheory.ClassGroup | ∀ {R : Type u_1} [inst : CommRing R] (x i : R), x * i ≠ 0 → ¬i = 0 | false |
_private.Mathlib.Topology.Connected.Basic.0.IsPreconnected.iUnion_of_reflTransGen._simp_1_1 | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
Equiv.optionCongr_apply | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (a : Option α), e.optionCongr a = Option.map (⇑e) a | true |
Turing.ToPartrec.stepRet.eq_def | Mathlib.Computability.TuringMachine.Config | ∀ (x : Turing.ToPartrec.Cont) (x_1 : List ℕ),
Turing.ToPartrec.stepRet x x_1 =
match x, x_1 with
| Turing.ToPartrec.Cont.halt, v => Turing.ToPartrec.Cfg.halt v
| Turing.ToPartrec.Cont.cons₁ fs as k, v => Turing.ToPartrec.stepNormal fs (Turing.ToPartrec.Cont.cons₂ v k) as
| Turing.ToPartrec.Cont.cons₂ ... | true |
Polynomial.le_gaussNorm | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u_1} {F : Type u_2} [inst : Semiring R] [inst_1 : FunLike F R ℝ] (v : F) {c : ℝ} (p : Polynomial R)
[ZeroHomClass F R ℝ] [NonnegHomClass F R ℝ], 0 ≤ c → ∀ (i : ℕ), v (p.coeff i) * c ^ i ≤ Polynomial.gaussNorm v c p | true |
Function.Injective.mulOneClass._proof_2 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : MulOneClass M₂] (f : M₁ → M₂),
f 1 = 1 → (∀ (x y : M₁), f (x * y) = f x * f y) → ∀ (x : M₁), f (x * 1) = f x | false |
WeierstrassCurve.toCharTwoNF_spec | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {F : Type u_2} [inst : Field F] [CharP F 2] (W : WeierstrassCurve F) [inst_2 : DecidableEq F],
(W.toCharTwoNF • W).IsCharTwoNF | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.toBitVec_eq_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false → b.toBitVec = 2#2 ++ BitVec.setWidth 6 b.toBitVec | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.