name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
HomologicalComplex.opcyclesMap_comp_descOpcycles | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K L : HomologicalComplex C c} {i : ι} [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i] {A : C} (k : L.X i ⟶ A) (j : ι) (hj : c.prev i = j)
(hk : CategoryTheory.CategoryStruct.comp (L.d j i) k = 0) (φ : K ⟶ L),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.opcyclesMap φ i) (L.descOpcycles k j hj hk) =
K.descOpcycles (CategoryTheory.CategoryStruct.comp (φ.f i) k) j hj ⋯ | true |
Mathlib.StacksTag.Database.kerodon.sizeOf_spec | Mathlib.Tactic.StacksAttribute | sizeOf Mathlib.StacksTag.Database.kerodon = 1 | true |
invMonoidHom._proof_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α], 1⁻¹ = 1 | false |
List.foldrRecOn_cons | Init.Data.List.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {b : β} {x : α} {l : List α} {motive : β → Sort u_3} {op : α → β → β} (hb : motive b)
(hl : (b : β) → motive b → (a : α) → a ∈ x :: l → motive (op a b)),
List.foldrRecOn (x :: l) op hb hl = hl (List.foldr op b l) (List.foldrRecOn l op hb fun b c a m => hl b c a ⋯) x ⋯ | true |
Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_right | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPartialOrder R]
[Lean.Grind.OrderedRing R] [Std.LawfulOrderLT R] {a b c : R}, a ≤ b → 0 ≤ c → a * c ≤ b * c | true |
Set.inter_diff_distrib_right | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (s t u : Set α), s \ t ∩ u = (s ∩ u) \ (t ∩ u) | true |
LinearEquiv.det_trans | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f g : M ≃ₗ[R] M),
LinearEquiv.det (f ≪≫ₗ g) = LinearEquiv.det g * LinearEquiv.det f | true |
AlgebraicGeometry.PresheafedSpace.stalkMap.congr_point | Mathlib.Geometry.RingedSpace.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C]
{X Y : AlgebraicGeometry.PresheafedSpace C} (α : X ⟶ Y) (x x' : ↑↑X) (h : x = x'),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap α x) (CategoryTheory.eqToHom ⋯) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap α x') | true |
Lean.Elab.Tactic.Try.Ctx.ctorIdx | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.Ctx → ℕ | false |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.isNilpotent_iff._simp_1_2 | Mathlib.Algebra.Lie.Nilpotent | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = (↑p = ↑q) | false |
Nat.filter_dvd_eq_properDivisors | Mathlib.NumberTheory.Divisors | ∀ {n : ℕ}, n ≠ 0 → {d ∈ Finset.range n | d ∣ n} = n.properDivisors | true |
CategoryTheory.Abelian.SpectralObject.isZero₂_of_isFirstQuadrant | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Y : CategoryTheory.Abelian.SpectralObject C EInt) [Y.IsFirstQuadrant] (i j : EInt) (hij : i ≤ j) (n : ℤ),
WithBotTop.coe n < i →
CategoryTheory.Limits.IsZero ((Y.H n).obj (CategoryTheory.ComposableArrows.mk₁ (CategoryTheory.homOfLE hij))) | true |
SimpleGraph.ConnectedComponent.Represents.ncard_eq | Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents | ∀ {V : Type u} {G : SimpleGraph V} {C : Set G.ConnectedComponent} {s : Set V},
SimpleGraph.ConnectedComponent.Represents s C → s.ncard = C.ncard | true |
map_extChartAt_nhds_of_boundaryless | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] [I.Boundaryless] (x : M),
Filter.map (↑(extChartAt I x)) (nhds x) = nhds (↑(extChartAt I x) x) | true |
Lean.Elab.Command.instHashableAssertExists.hash | Lean.Elab.AssertExists | Lean.Elab.Command.AssertExists → UInt64 | true |
Std.Sat.AIG.RelabelNat.State.Inv2.brecOn | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)}
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1 → Prop} {a : ℕ}
{a_1 : Std.HashMap α ℕ} (t : Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1),
(∀ (a : ℕ) (a_2 : Std.HashMap α ℕ) (t : Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_2),
Std.Sat.AIG.RelabelNat.State.Inv2.below t → motive a a_2 t) →
motive a a_1 t | true |
Polynomial.Separable.eq_1 | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] (f : Polynomial R), f.Separable = IsCoprime f (Polynomial.derivative f) | true |
Int.quotientZMultiplesEquivZMod._proof_2 | Mathlib.Data.ZMod.QuotientGroup | ∀ (a : ℤ), (AddSubgroup.zmultiples ↑a.natAbs).Normal | false |
Std.DTreeMap.Internal.Impl.insertManyIfNew._proof_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β) (h : t.Balanced)
(r : t.IteratedNewInsertionInto) (a : α) (b : β a) {P : Std.DTreeMap.Internal.Impl α β → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α β) (a : α) (b : β a) (h : t''.Balanced),
P t'' → P (Std.DTreeMap.Internal.Impl.insertIfNew a b t'' h).impl) →
P (Std.DTreeMap.Internal.Impl.insertIfNew a b ↑r ⋯).impl | false |
instOrOpUInt32 | Init.Data.UInt.Basic | OrOp UInt32 | true |
TopologicalSpace.IsCompletelyMetrizableSpace.mk | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_3} [t : TopologicalSpace X],
(∃ m, PseudoMetricSpace.toUniformSpace.toTopologicalSpace = t ∧ CompleteSpace X) →
TopologicalSpace.IsCompletelyMetrizableSpace X | true |
Matroid.«_aux_Mathlib_Combinatorics_Matroid_Minor_Restrict___macroRules_Matroid_term_≤r__1» | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.Macro | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_eq_iff_of_getLsbD_false._proof_1_10 | Init.Data.BitVec.Lemmas | ∀ (n j : ℕ), j ≤ n + 1 → ¬j = n + 1 → ¬j ≤ n → False | false |
SSet.Subcomplex.N._sizeOf_inst | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | {X : SSet} → (A : X.Subcomplex) → SizeOf A.N | false |
IsCoatomistic.recOn | Mathlib.Order.Atoms | {α : Type u_2} →
[inst : PartialOrder α] →
[inst_1 : OrderTop α] →
{motive : IsCoatomistic α → Sort u} →
(t : IsCoatomistic α) →
((isGLB_coatoms : ∀ (b : α), ∃ s, IsGLB s b ∧ ∀ a ∈ s, IsCoatom a) → motive ⋯) → motive t | false |
Int.toList_rcc_succ_succ | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, ((m + 1)...=n + 1).toList = List.map (fun x => x + 1) (m...=n).toList | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.nnrpow_sqrt_two._simp_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ) [inst_2 : n.AtLeastTwo], (OfNat.ofNat n = 0) = False | false |
DFinsupp.zipWith_apply | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [inst : (i : ι) → Zero (β i)]
[inst_1 : (i : ι) → Zero (β₁ i)] [inst_2 : (i : ι) → Zero (β₂ i)] (f : (i : ι) → β₁ i → β₂ i → β i)
(hf : ∀ (i : ι), f i 0 0 = 0) (g₁ : Π₀ (i : ι), β₁ i) (g₂ : Π₀ (i : ι), β₂ i) (i : ι),
(DFinsupp.zipWith f hf g₁ g₂) i = f i (g₁ i) (g₂ i) | true |
HasDerivAt.tendsto_slope | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜},
HasDerivAt f f' x → Filter.Tendsto (slope f x) (nhdsWithin x {x}ᶜ) (nhds f') | true |
ForInStep.done.noConfusion | Init.Core | {α : Type u} → {P : Sort u_1} → {a a' : α} → ForInStep.done a = ForInStep.done a' → (a ≍ a' → P) → P | false |
Lean.Compiler.CSimp.State.rec | Lean.Compiler.CSimpAttr | {motive : Lean.Compiler.CSimp.State → Sort u} →
((map : Lean.SMap Lean.Name Lean.Compiler.CSimp.Entry) →
(thmNames : Lean.SSet Lean.Name) → motive { map := map, thmNames := thmNames }) →
(t : Lean.Compiler.CSimp.State) → motive t | false |
CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁ | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [CategoryTheory.EnoughInjectives C] [CategoryTheory.Mono f] (n₀ n₁ : ℤ),
(∀ i ≤ n₀, QuasiIsoAt f i) →
autoParam (n₀ + 1 = n₁) CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁._auto_1 →
∃ F,
CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.quasiIsoLE n₀ F ∧
CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.isIsoLE n₀ F ∧
CategoryTheory.Mono (HomologicalComplex.homologyMap F.obj.ι n₁) | true |
CategoryTheory.Limits.Cone.category._proof_3 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C}
{X Y Z : CategoryTheory.Limits.Cone F} (f : CategoryTheory.Limits.ConeMorphism X Y)
(g : CategoryTheory.Limits.ConeMorphism Y Z) (j : J),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f.hom g.hom) (Z.π.app j) = X.π.app j | false |
Valuation.Integers.mem_of_integral | Mathlib.RingTheory.Valuation.Integral | ∀ {R : Type u} {Γ₀ : Type v} [inst : CommRing R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation R Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O R], v.Integers O → ∀ {x : R}, IsIntegral O x → x ∈ v.integer | true |
CategoryTheory.ShortComplex.isIso_iCycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology], S.g = 0 → CategoryTheory.IsIso S.iCycles | true |
_private.Init.Data.List.MinMaxOn.0.List.maxOn_append._simp_1_3 | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | false |
MultilinearMap.coe_currySumEquiv_symm | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] {N : ι ⊕ ι' → Type u_1} [inst_3 : (i : ι ⊕ ι') → AddCommMonoid (N i)]
[inst_4 : (i : ι ⊕ ι') → Module R (N i)], ⇑MultilinearMap.currySumEquiv.symm = MultilinearMap.uncurrySum | true |
RestrictedProduct.instCommMonoidCoeOfSubmonoidClass._proof_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_3} (R : ι → Type u_2) {S : ι → Type u_1} [inst : (i : ι) → SetLike (S i) (R i)]
[inst_1 : (i : ι) → CommMonoid (R i)] [∀ (i : ι), SubmonoidClass (S i) (R i)] (i : ι), OneMemClass (S i) (R i) | false |
Std.ExtTreeMap.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k fallback : α},
t.erase k ≠ ∅ → ¬cmp k (t.minKeyD fallback) = Ordering.eq → (t.erase k).minKeyD fallback = t.minKeyD fallback | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.ext_iff | 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}
{x y : A.Hom B}, x = y ↔ x.val = y.val | true |
CategoryTheory.Pseudofunctor.Grothendieck.categoryStruct_comp_fiber | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} {X x x_1 : F.Grothendieck}
(f : X.Hom x) (g : x.Hom x_1),
(CategoryTheory.CategoryStruct.comp f g).fiber =
CategoryTheory.CategoryStruct.comp ((F.mapComp f.base.toLoc g.base.toLoc).hom.toNatTrans.app X.fiber)
(CategoryTheory.CategoryStruct.comp ((F.map g.base.toLoc).toFunctor.map f.fiber) g.fiber) | true |
WithLp.map_comp | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) {V : Type u_4} {V' : Type u_5} {V'' : Type u_6} (f : V' → V'') (g : V → V'),
WithLp.map p (f ∘ g) = WithLp.map p f ∘ WithLp.map p g | true |
Lean.Meta.Grind.EMatchTheoremKind.casesOn | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremKind) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqBoth gen)) →
motive Lean.Meta.Grind.EMatchTheoremKind.eqBwd →
motive Lean.Meta.Grind.EMatchTheoremKind.fwd →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.bwd gen)) →
motive Lean.Meta.Grind.EMatchTheoremKind.leftRight →
motive Lean.Meta.Grind.EMatchTheoremKind.rightLeft →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.default gen)) →
motive Lean.Meta.Grind.EMatchTheoremKind.user → motive t | false |
Lean.Meta.Grind.Order.instInhabitedCnstr | Lean.Meta.Tactic.Grind.Order.Types | {a : Type} → [Inhabited a] → Inhabited (Lean.Meta.Grind.Order.Cnstr a) | true |
Std.TreeMap.size_left_le_size_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
t₁.size ≤ (t₁ ∪ t₂).size | true |
List.Perm.filterMap | Init.Data.List.Perm | ∀ {α : Type u_1} {β : Type u_2} (f : α → Option β) {l₁ l₂ : List α},
l₁.Perm l₂ → (List.filterMap f l₁).Perm (List.filterMap f l₂) | true |
_private.Mathlib.LinearAlgebra.Multilinear.DFinsupp.0.MultilinearMap.dfinsuppFamily._simp_2 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {α : Type u_1} [inst : DecidableEq α] {β : α → Type u_2} (m : Multiset α) (t : (a : α) → Multiset (β a))
(f : (a : α) → a ∈ m → β a), (f ∈ m.pi t) = ∀ (a : α) (h : a ∈ m), f a h ∈ t a | false |
sdiff_le_inf_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, a \ b ≤ a ⊓ ￢b | true |
addUnitsCenterToCenterAddUnits.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ (M : Type u_1) [inst : AddMonoid M],
addUnitsCenterToCenterAddUnits M =
(AddUnits.map (AddSubmonoid.center M).subtype).codRestrict (AddSubmonoid.center (AddUnits M)) ⋯ | true |
CompleteSublattice.ext_iff | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {S T : ↥L}, S = T ↔ ∀ (x : X), x ∈ S ↔ x ∈ T | true |
CategoryTheory.Limits.ι_comp_colimitLeftOpIsoUnopLimit_hom | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor J Cᵒᵖ) [inst_2 : CategoryTheory.Limits.HasLimit F] (j : Jᵒᵖ),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F.leftOp j)
(CategoryTheory.Limits.colimitLeftOpIsoUnopLimit F).hom =
(CategoryTheory.Limits.limit.π F (Opposite.unop j)).unop | true |
sSupHom.rec | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
[inst : SupSet α] →
[inst_1 : SupSet β] →
{motive : sSupHom α β → Sort u} →
((toFun : α → β) →
(map_sSup' : ∀ (s : Set α), toFun (sSup s) = sSup (toFun '' s)) →
motive { toFun := toFun, map_sSup' := map_sSup' }) →
(t : sSupHom α β) → motive t | false |
Quaternion.imJ_fst_dualNumberEquiv | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R] (q : Quaternion (DualNumber R)),
(TrivSqZeroExt.fst (Quaternion.dualNumberEquiv q)).imJ = TrivSqZeroExt.fst q.imJ | true |
FiberPrebundle.totalSpaceMk_preimage_source | Mathlib.Topology.FiberBundle.Basic | ∀ {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : (x : B) → TopologicalSpace (E x)] (a : FiberPrebundle F E) (b : B),
Bundle.TotalSpace.mk b ⁻¹' (a.pretrivializationAt b).source = Set.univ | true |
derivWithin_ofNat | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (n : ℕ) [inst_3 : OfNat F n], derivWithin (OfNat.ofNat n) s = 0 | true |
_private.Mathlib.RingTheory.KrullDimension.Basic.0.Ring.krullDimLE_one_iff._simp_1_1 | Mathlib.RingTheory.KrullDimension.Basic | ∀ (n : ℕ) (α : Type u_1) [inst : Preorder α], Order.KrullDimLE n α = (Order.krullDim α ≤ ↑n) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_inter_of_contains_eq_false_right._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Lean.«_aux_Init_BinderPredicates___macroRules_Lean_term∃__,__1» | Init.BinderPredicates | Lean.Macro | false |
Lean.Firefox.RawMarkerTable.name | Lean.Util.Profiler | Lean.Firefox.RawMarkerTable → Array Lean.Json | true |
_private.Mathlib.FieldTheory.Normal.Closure.0.IntermediateField.normalClosure_def'.match_1_3 | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_2} {L : Type u_1} [inst : Field F] [inst_1 : Field L] [inst_2 : Algebra F L] (K : IntermediateField F L)
(f : L →ₐ[F] L) (b : L) (motive : b ∈ IntermediateField.map f K → Prop) (x : b ∈ IntermediateField.map f K),
(∀ (a : L) (h : a ∈ ↑K.toSubsemiring ∧ ↑f a = b), motive ⋯) → motive x | false |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.exists_Gamma_le_conj._simp_1_1 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (A B : GL n R),
↑A * ↑B = ↑(A * B) | false |
Lean.AttributeExtensionState.ctorIdx | Lean.Attributes | Lean.AttributeExtensionState → ℕ | false |
Mathlib.Tactic.ITauto.prove._unsafe_rec | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Context → Mathlib.Tactic.ITauto.IProp → StateM ℕ (Bool × Mathlib.Tactic.ITauto.Proof) | false |
Lean.Lsp.instFileSourceTextDocumentPositionParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.TextDocumentPositionParams | true |
LightCondSet | Mathlib.Condensed.Light.Basic | Type (u + 1) | true |
CategoryTheory.Linear | Mathlib.CategoryTheory.Linear.Basic | (R : Type w) →
[Semiring R] →
(C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.Preadditive C] → Type (max (max u v) w) | true |
CategoryTheory.GrothendieckTopology.Point.presheafFiberDesc | Mathlib.CategoryTheory.Sites.Point.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
(Φ : J.Point) →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
[inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A] →
{P : CategoryTheory.Functor Cᵒᵖ A} →
{T : A} →
(φ : (X : C) → Φ.fiber.obj X → (P.obj (Opposite.op X) ⟶ T)) →
autoParam
(∀ ⦃X Y : C⦄ (f : X ⟶ Y) (x : Φ.fiber.obj X),
CategoryTheory.CategoryStruct.comp (P.map f.op) (φ X x) = φ Y (Φ.fiber.map f x))
_auto_48✝ →
(Φ.presheafFiber.obj P ⟶ T) | true |
_private.Lean.Elab.MatchExpr.0.Lean.Elab.Term.MatchExpr.next.match_1 | Lean.Elab.MatchExpr | (motive : List (Option Lean.Ident) → Sort u_1) →
(x : List (Option Lean.Ident)) →
((pvars : List (Option Lean.Ident)) → motive (none :: pvars)) →
((x : List (Option Lean.Ident)) → motive x) → motive x | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cons_append._proof_1 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ : ℕ}, ¬w₁ + w₂ + 1 = w₁ + 1 + w₂ → False | false |
Filter.instInf._proof_2 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (f g : Filter α) {x y : Set α},
x ∈ {s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b} → x ⊆ y → y ∈ {s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b} | false |
LocallyConstant.coeFnAlgHom._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (R : Type u_3) [inst_1 : CommSemiring R]
[inst_2 : Semiring Y] [inst_3 : Algebra R Y] (x : R),
(↑↑LocallyConstant.coeFnRingHom).toFun ((algebraMap R (LocallyConstant X Y)) x) =
(↑↑LocallyConstant.coeFnRingHom).toFun ((algebraMap R (LocallyConstant X Y)) x) | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.inductiveElabAttr.unsafe_impl_3 | Lean.Elab.MutualInductive | IO (Lean.KeyedDeclsAttribute Lean.Elab.Command.InductiveElabDescr) | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_14 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt32), a - 0 = a | false |
Std.DTreeMap.Internal.RcoSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.RcoSliceData α β → Sort u_1} →
(t : Std.DTreeMap.Internal.RcoSliceData α β) →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Rco α) → motive { treeMap := treeMap, range := range }) →
motive t | false |
SimplexCategory.skeletalEquivalence | Mathlib.AlgebraicTopology.SimplexCategory.Basic | SimplexCategory ≌ NonemptyFinLinOrd | true |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.finite_finsupp_iff._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | false |
Lean.IR.EmitLLVM.declareVars._unsafe_rec | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → LLVM.Builder llvmctx → Lean.IR.FnBody → Lean.IR.EmitLLVM.M llvmctx Unit | false |
BddLat.Iso.mk._proof_6 | Mathlib.Order.Category.BddLat | ∀ {α β : BddLat} (e : ↑α.toLat ≃o ↑β.toLat) (a b : ↑α.1),
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | false |
gronwallBound_x0 | Mathlib.Analysis.ODE.Gronwall | ∀ (δ K ε : ℝ), gronwallBound δ K ε 0 = δ | true |
Std.HashMap.Raw.Equiv.diff_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ m₃ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁ \ m₂).Equiv (m₁ \ m₃) | true |
_private.Mathlib.SetTheory.ZFC.Class.0.ZFSet.coe_equiv_aux._simp_1_1 | Mathlib.SetTheory.ZFC.Class | ∀ (x : PSet.{u_1}), x.Equiv x = True | false |
Lean.Grind.instSubNatCiOfNatInt | Init.GrindInstances.ToInt | Lean.Grind.ToInt.Sub ℕ (Lean.Grind.IntInterval.ci 0) | true |
_private.Mathlib.Order.Bounds.Basic.0.upperBounds_empty._simp_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_decl_eq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(cin : aig.Ref) (s : aig.RefVec curr) (lhs rhs : aig.RefVec w) (idx : ℕ) (h1 : idx < aig.decls.size)
(h2 : idx < (Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go aig lhs rhs curr hcurr cin s).aig.decls.size),
(Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go aig lhs rhs curr hcurr cin s).aig.decls[idx] = aig.decls[idx] | true |
Lean.Parser.setExpected | Lean.Parser.Basic | List String → Lean.Parser.Parser → Lean.Parser.Parser | true |
Polynomial.dickson_of_two_le | Mathlib.RingTheory.Polynomial.Dickson | ∀ {R : Type u_1} [inst : CommRing R] (k : ℕ) (a : R) {n : ℕ},
2 ≤ n →
Polynomial.dickson k a n =
Polynomial.X * Polynomial.dickson k a (n - 1) - Polynomial.C a * Polynomial.dickson k a (n - 2) | true |
UInt8.toUInt64_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a <<< b).toUInt64 = a.toUInt64 <<< (b % 8).toUInt64 % 256 | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.hasPullback_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Z)
[hf : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (g : Y ⟶ Z), CategoryTheory.Limits.HasPullback g f | true |
LightDiagram.cone | Mathlib.Topology.Category.LightProfinite.Basic | (self : LightDiagram) → CategoryTheory.Limits.Cone (self.diagram.comp FintypeCat.toProfinite) | true |
Equidecomp.mk._flat_ctor | Mathlib.Algebra.Group.Action.Equidecomp | {X : Type u_1} →
{G : Type u_2} →
[inst : SMul G X] →
(toFun invFun : X → X) →
(source target : Set X) →
(∀ ⦃x : X⦄, x ∈ source → toFun x ∈ target) →
(∀ ⦃x : X⦄, x ∈ target → invFun x ∈ source) →
(∀ ⦃x : X⦄, x ∈ source → invFun (toFun x) = x) →
(∀ ⦃x : X⦄, x ∈ target → toFun (invFun x) = x) →
(∃ S, Equidecomp.IsDecompOn toFun source S) → Equidecomp X G | false |
_private.Batteries.Data.List.Basic.0.List.rotate.match_1.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α × List α → Sort u_2) (l₁ l₂ : List α) (h_1 : (l₁ l₂ : List α) → motive (l₁, l₂)),
(match (l₁, l₂) with
| (l₁, l₂) => h_1 l₁ l₂) =
h_1 l₁ l₂ | true |
Polynomial.SplittingField.instField._proof_13 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K], IsScalarTower ℚ K K | false |
Algebra.FormallyUnramified.isRadical_map_isMaximal | Mathlib.RingTheory.Unramified.Field | ∀ (A : Type u_2) [inst : CommRing A] (B : Type u_4) [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Algebra.EssFiniteType A B] [Algebra.FormallyUnramified A B] (p : Ideal A) [p.IsMaximal],
(Ideal.map (algebraMap A B) p).IsRadical | true |
Configuration.HasPoints.hasLines._proof_1 | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_2} {L : Type u_1} [inst : Fintype P] [inst_1 : Fintype L],
Fintype.card P = Fintype.card L → Fintype.card L = Fintype.card P | false |
IsNonarchimedeanLocalField.instCompleteSpace | Mathlib.NumberTheory.LocalField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K] [IsUniformAddGroup K]
[IsNonarchimedeanLocalField K], CompleteSpace K | true |
CategoryTheory.CartesianMonoidalCategory.lift_comp_fst_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X Y Z : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z),
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.SemiCartesianMonoidalCategory.fst Y Z))
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.SemiCartesianMonoidalCategory.snd Y Z)) =
f | true |
Subrel.inclusionEmbedding._proof_1 | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} {s t : Set α} (h : s ⊆ t) (x x_1 : { x // x ∈ s }), Set.inclusion h x = Set.inclusion h x_1 → x = x_1 | false |
CategoryTheory.Grp.trivial._proof_1 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
autoParam
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(CategoryTheory.CategoryStruct.id (CategoryTheory.Mon.trivial C).X))
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.SemiCartesianMonoidalCategory.toUnit (CategoryTheory.Mon.trivial C).X)
CategoryTheory.MonObj.one)
CategoryTheory.GrpObj.left_inv._autoParam | false |
NormedSpace.casesOn | Mathlib.Analysis.Normed.Module.Basic | {𝕜 : Type u_6} →
{E : Type u_7} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
{motive : NormedSpace 𝕜 E → Sort u} →
(t : NormedSpace 𝕜 E) →
([toModule : Module 𝕜 E] →
(norm_smul_le : ∀ (a : 𝕜) (b : E), ‖a • b‖ ≤ ‖a‖ * ‖b‖) →
motive { toModule := toModule, norm_smul_le := norm_smul_le }) →
motive t | false |
Ideal.stableFiltration_N | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
(N : Submodule R M) (i : ℕ), (I.stableFiltration N).N i = I ^ i • N | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.