name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.elim | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
t.ctorIdx = 3 →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) →
motive t | false |
UInt8._sizeOf_inst | Init.SizeOf | SizeOf UInt8 | false |
Int.reduceNeg._regBuiltin.Int.reduceNeg.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2123988823._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_target._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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... | false |
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists.match_1_3 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {p : Finset α → Prop} (motive : (∃ s, ∃ (hs : s.Finite), p hs.toFinset) → Prop)
(x : ∃ s, ∃ (hs : s.Finite), p hs.toFinset),
(∀ (s : Set α) (hs : s.Finite) (hs' : p hs.toFinset), motive ⋯) → motive x | false |
UnitAddTorus.mFourierLp._proof_7 | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {d : Type u_1}, CompactSpace (d → UnitAddCircle) | false |
IsAbsoluteValue.abv_nonneg | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] (abv : R → S)
[IsAbsoluteValue abv] (x : R), 0 ≤ abv x | true |
EReal.coe_ennreal_le_coe_ennreal_iff._simp_1 | Mathlib.Data.EReal.Basic | ∀ {x y : ENNReal}, (↑x ≤ ↑y) = (x ≤ y) | false |
CategoryTheory.nerveFunctor.full | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | CategoryTheory.nerveFunctor.Full | true |
CategoryTheory.Presieve.BindStruct.hg | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h),
R ⋯ self.g | true |
Pi.comul_coe_finsupp | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Type u_4}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : CoalgebraStruct R M] (x : n →₀ M),
CoalgebraStruct.comul ⇑x = (TensorProduct.map Finsupp.lcoeFun Finsupp.lcoeFun) (CoalgebraStruct.comul x) | true |
ModuleCat.monModuleEquivalenceAlgebraForget._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : CategoryTheory.Mon (ModuleCat R)) (x : R)
(x_1 : ↑(ModuleCat.MonModuleEquivalenceAlgebra.functor.obj A)), id (x • x_1) = id (x • x_1) | false |
CategoryTheory.Limits.prod.mapIso_hom | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W ≅ Y) (g : X ≅ Z), (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_of_msb_false._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {p : Prop} [h : Decidable p], (false = decide p) = ¬p | false |
Lean.Server.Snapshots.Snapshot.recOn | Lean.Server.Snapshots | {motive : Lean.Server.Snapshots.Snapshot → Sort u} →
(t : Lean.Server.Snapshots.Snapshot) →
((stx : Lean.Syntax) →
(mpState : Lean.Parser.ModuleParserState) →
(cmdState : Lean.Elab.Command.State) → motive { stx := stx, mpState := mpState, cmdState := cmdState }) →
motive t | false |
AddLocalization.liftOn₂_mk | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → ↥S → M → ↥S → p)
(H :
∀ {a a' : M} {b b' : ↥S} {c c' : M} {d d' : ↥S},
(AddLocalization.r S) (a, b) (a', b') → (AddLocalization.r S) (c, d) (c', d') → f a b c d = f a' b' c' d')
(a c : M) (b d : ↥S), (AddLocalization.mk... | true |
CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(F₁ : CategoryTheory.Functor J C) {F₂ F₂' : CategoryTheory.Functor J C} (g : F₂ ⟶ F₂') (j : J),
CategoryTheory.CategoryStruct.comp ((C... | true |
Polynomial.map_evalRingHom_eval | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p | true |
MulArchimedeanClass.mk_right_le_mk_mul_iff._simp_2 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk (a * b)) = (MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk a) | false |
Units.isOpenMap_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], IsOpenMap Units.val | true |
IsSemisimpleModule.recOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSemisimpleModule R M → Sort u} →
(t : IsSemisimpleModule R M) →
([toComplementedLattice : ComplementedLattice (Submodule R M)] → motive ⋯) → motive ... | false |
Pi.instSub | Mathlib.Algebra.Notation.Pi.Defs | {ι : Type u_1} → {G : ι → Type u_4} → [(i : ι) → Sub (G i)] → Sub ((i : ι) → G i) | true |
_private.Mathlib.CategoryTheory.GlueData.0.CategoryTheory.GlueData.π_epi._proof_1 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : CategoryTheory.GlueData C)
[inst_1 : CategoryTheory.Limits.HasMulticoequalizer D.diagram] [inst_2 : CategoryTheory.Limits.HasColimits C],
CategoryTheory.Epi D.π | false |
Set.Definable.compl | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {s : Set (α → M)},
A.Definable L s → A.Definable L sᶜ | true |
PresheafOfModules.instIsLocalizationSheafOfModulesSheafificationInverseImageFunctorOppositeAbWToPresheaf | Mathlib.Algebra.Category.ModuleCat.Sheaf.Localization | ∀ {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 |
left_subset_compRel | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {s t : SetRel α α}, idRel ⊆ t → s ⊆ s.comp t | true |
Std.DHashMap.get?_eq_some_getD | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a}, a ∈ m → m.get? a = some (m.getD a fallback) | true |
Finset.sup_eq_sSup_image | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset α) (f : α → β), s.sup f = sSup (f '' ↑s) | true |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier | Mathlib.Algebra.Category.MonCat.Basic | CategoryTheory.ConcreteCategory AddCommMonCat fun x1 x2 => ↑x1 →+ ↑x2 | true |
Ordinal.typein_lt_nat | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (x : ℕ), (Ordinal.typein LT.lt).toRelEmbedding x = ↑x | true |
_private.Mathlib.Probability.Distributions.Exponential.0.ProbabilityTheory.cdf_expMeasure_eq._simp_1_3 | Mathlib.Probability.Distributions.Exponential | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a : α}, (-a ≤ 0) = (0 ≤ a) | false |
CategoryTheory.Functor.OplaxMonoidal.instIsIsoη | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] [CategoryTheory.Limits.Prese... | true |
WCovBy.eq_or_covBy._to_dual_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ⩿ a → a = b ∨ b ⋖ a | false |
CompactExhaustion.mk.inj | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_4} {inst : TopologicalSpace X} {toFun : ℕ → Set X} {isCompact' : ∀ (n : ℕ), IsCompact (toFun n)}
{subset_interior_succ' : ∀ (n : ℕ), toFun n ⊆ interior (toFun (n + 1))} {iUnion_eq' : ⋃ n, toFun n = Set.univ}
{toFun_1 : ℕ → Set X} {isCompact'_1 : ∀ (n : ℕ), IsCompact (toFun_1 n)}
{subset_interior_suc... | true |
Fin.shiftLeft | Init.Data.Fin.Basic | {n : ℕ} → Fin n → Fin n → Fin n | true |
Matrix.uniqueEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : Unique m] [inst_1 : Unique n] (a : A),
Matrix.uniqueEquiv.symm a = Matrix.of fun x x_1 => a | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_3 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | false |
Mathlib.Tactic.Abel._aux_Mathlib_Tactic_Abel___macroRules_Mathlib_Tactic_Abel_abel1!_1 | Mathlib.Tactic.Abel | Lean.Macro | false |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_inv_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b) {Z : F.obj a ⟶ F.obj b}
(h : CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.CategoryStruct.id b)) ⟶ Z),
CategoryTheory.Categor... | true |
IntermediateField.exists_algHom_of_splits_of_aeval | Mathlib.FieldTheory.Extension | ∀ {F : Type u_1} {E : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K],
(∀ (s : E), IsIntegral F s ∧ (Polynomial.map (algebraMap F K) (minpoly F s)).Splits) →
∀ {x : E} {y : K}, (Polynomial.aeval y) (minpoly F x) = 0 → ∃ φ, φ x = y | true |
Finset.nontrivial_iff_ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, a ∈ s → (s.Nontrivial ↔ s ≠ {a}) | true |
PartOrdEmb.dual._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ (X : PartOrdEmb),
PartOrdEmb.ofHom (PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X)).dual =
CategoryTheory.CategoryStruct.id { carrier := (↑X)ᵒᵈ, str := OrderDual.instPartialOrder ↑X } | false |
Plausible.InjectiveFunction.sliceSizes.eq_def | Mathlib.Testing.Plausible.Functions | ∀ (x : ℕ),
Plausible.InjectiveFunction.sliceSizes x =
let n := x;
if h : 0 < n then
have this := ⋯;
MLList.cons ⟨n, h⟩ (Plausible.InjectiveFunction.sliceSizes (n / 2))
else MLList.nil | true |
pure_le_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X], pure ≤ nhds | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._simp_1_5 | Init.Data.BitVec.Bitblast | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | false |
Lean.Elab.Term.MutualClosure.FixPoint.run | Lean.Elab.MutualDef | Array Lean.FVarId → Lean.Elab.Term.MutualClosure.UsedFVarsMap → Lean.Elab.Term.MutualClosure.UsedFVarsMap | true |
Function.HasFiniteSupport.sup | Mathlib.Algebra.FiniteSupport.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : SemilatticeSup M] {f g : α → M},
Function.HasFiniteSupport f → Function.HasFiniteSupport g → Function.HasFiniteSupport fun a => f a ⊔ g a | true |
NonemptyFinLinOrd.ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | {X Y : Type u} →
[inst : Nonempty X] →
[inst_1 : LinearOrder X] →
[inst_2 : Fintype X] →
[inst_3 : Nonempty Y] →
[inst_4 : LinearOrder Y] → [inst_5 : Fintype Y] → (X →o Y) → (NonemptyFinLinOrd.of X ⟶ NonemptyFinLinOrd.of Y) | true |
Ideal.under_under | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_2} [inst : CommSemiring A] {B : Type u_3} [inst_1 : CommSemiring B] {C : Type u_4} [inst_2 : Semiring C]
[inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C] [IsScalarTower A B C] (𝔓 : Ideal C),
Ideal.under A (Ideal.under B 𝔓) = Ideal.under A 𝔓 | true |
_private.Init.Data.Int.LemmasAux.0.Int.min_assoc._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬min (min a b) c = min a (min b c) → False | false |
List.infix_filter_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α}, l₂ <:+: List.filter p l₁ ↔ ∃ l, l <:+: l₁ ∧ l₂ = List.filter p l | true |
Std.Do.SPred.true_intro | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs}, P ⊢ₛ ⌜True⌝ | true |
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.addG.match_1 | Mathlib.Tactic.Abel | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → ((p : Lean.Name) → (s : String) → motive (p.str s)) → ((n : Lean.Name) → motive n) → motive x | false |
BoxIntegral.Box.Ioo_subset_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), BoxIntegral.Box.Ioo I ⊆ ↑I | true |
FormalMultilinearSeries.coeff_eq_zero | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {n : ℕ}, p.coeff n = 0 ↔ p n = 0 | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_5.splitter | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(rs : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l_1 : Std.DTreeMap.Internal.Impl α β) →
l_1.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecon... | true |
Subsemigroup.range_subtype | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (s : Subsemigroup M), (MulMemClass.subtype s).srange = s | true |
ValuationSubring.instFieldSubtypeMemTop._proof_4 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K], SubringClass (Subfield K) K | false |
String.Pos.Raw.isValidForSlice_stringSliceTo | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos} {q : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice (s.sliceTo p) q ↔ q ≤ p.offset ∧ String.Pos.Raw.IsValid s q | true |
Lean.Meta.instInhabitedUnificationHints.default | Lean.Meta.UnificationHint | Lean.Meta.UnificationHints | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_6 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (a : ι) (l : List ι) (n : ℕ), n + 2 ≤ (a :: l).length → n + 1 < (a :: l).length | false |
CategoryTheory.Triangulated.TStructure.truncGEδLT_comp_truncLTι_app | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | true |
Lean.Omega.LinearCombo.coordinate_eval_0 | Init.Omega.LinearCombo | ∀ {a0 : ℤ} {t : List ℤ}, (Lean.Omega.LinearCombo.coordinate 0).eval (Lean.Omega.Coeffs.ofList (a0 :: t)) = a0 | true |
Bundle.Pretrivialization.linearMapAt_def_of_notMem | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : AddCommMonoid F] [inst_4 : Module R F]
[inst_5 : (x : B) → AddCommMonoid (E x)] [inst_6 : (x : B) → Module R (E x)]
(e : Bundle.Pretrivialization F Bundle.Tot... | true |
AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.isLocallyFraction | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
TopCat.LocalPredicate fun x => HomogeneousLocalization.AtPrime 𝒜 x.asHomogeneousIdeal.toIdeal | true |
List.eq_nil_of_map_eq_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l = [] → l = [] | true |
Lean.Elab.ContextInfo.parentDecl?._default | Lean.Elab.InfoTree.Types | Option Lean.Name | false |
CategoryTheory.OplaxFunctor.comp | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Bicategory D] →
CategoryTheory.OplaxFunctor B C → CategoryTheory.OplaxFunctor C D → CategoryTheory.OplaxFunctor B D | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.msgToInteractive.match_3 | Lean.Widget.InteractiveDiagnostic | (motive : Lean.Widget.EmbedFmt✝ → Sort u_1) →
(x : Lean.Widget.EmbedFmt✝¹) →
((ctx : Lean.Elab.ContextInfo) →
(infos : Std.TreeMap ℕ Lean.Elab.Info compare) → motive (Lean.Widget.EmbedFmt.code✝ ctx infos)) →
((ctx : Lean.Elab.ContextInfo) →
(lctx : Lean.LocalContext) → (g : Lean.MVarId) → ... | false |
Associates.FactorSet.prod | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {α : Type u_1} → [inst : CommMonoidWithZero α] → Associates.FactorSet α → Associates α | true |
List.length_product | Mathlib.Data.List.ProdSigma | ∀ {α : Type u_1} {β : Type u_2} (l₁ : List α) (l₂ : List β), (l₁ ×ˢ l₂).length = l₁.length * l₂.length | true |
FirstOrder.Language.IsRelational | Mathlib.ModelTheory.Basic | FirstOrder.Language → Prop | true |
Submodule.map.congr_simp | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] (f f_1 : M →ₛₗ[σ₁₂] M₂),
f = f_1 → ∀ (p p_1 : Submodule ... | true |
CategoryTheory.ShortComplex.moduleCat_exact_iff | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact ↔
∀ (x₂ : ↑S.X₂),
(CategoryTheory.ConcreteCategory.hom S.g) x₂ = 0 → ∃ x₁, (CategoryTheory.ConcreteCategory.hom S.f) x₁ = x₂ | true |
CategoryTheory.IsCofiltered.nonempty | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.IsCofiltered C], Nonempty C | true |
Lean.Widget.inst._@.Lean.Widget.Basic.2038268869._hygCtx._hyg.3 | Lean.Widget.Basic | TypeName Lean.Elab.InfoWithCtx | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.noConfusionType | Lean.Meta.Tactic.Grind.Split | Sort u → Lean.Meta.Grind.SplitCandidate✝ → Lean.Meta.Grind.SplitCandidate✝ → Sort u | false |
CategoryTheory.Retract.op_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Retract X Y), h.op.i = h.r.op | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.isHashSelf_filterMapₘ._simp_1_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | false |
Std.DHashMap.isEmpty_insertMany_list | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)}, (m.insertMany l).isEmpty = (m.isEmpty && l.isEmpty) | true |
CategoryTheory.Limits.spanExt_inv_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X ≅ X') (iY : Y ≅ Y') (iZ : Z ≅ Z')
{f : X ⟶ Y} {g : X ⟶ Z} {f' : X' ⟶ Y'} {g' : X' ⟶ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iY.hom)
(wg : CategoryTheory.CategoryStruct.comp i... | true |
CategoryTheory.IsAccessibleCategory.rec | Mathlib.CategoryTheory.Presentable.LocallyPresentable | {C : Type u} →
[hC : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsAccessibleCategory.{w, v, u} C → Sort u_1} →
((exists_cardinal : ∃ κ, ∃ (x : Fact κ.IsRegular), CategoryTheory.IsCardinalAccessibleCategory C κ) → motive ⋯) →
(t : CategoryTheory.IsAccessibleCategory.{w, v, u} C) → m... | false |
IntermediateField.isIntegral_iff | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {S : IntermediateField K L}
{x : ↥S}, IsIntegral K x ↔ IsIntegral K ↑x | true |
Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer._regBuiltin.Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer_1 | Lean.Parser | IO Unit | false |
AlgebraicGeometry.Scheme.IdealSheafData.support_antitone | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Antitone AlgebraicGeometry.Scheme.IdealSheafData.support | true |
CategoryTheory.CatCenter.localizationRingHom | Mathlib.CategoryTheory.Center.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →
[inst_3 : CategoryTheory.Preadditive C... | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_3 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ),
acc + ↑(Std.Time.Month.Ordinal.days leap idx) - acc = ↑(Std.Time.Month.Ordinal.days leap idx) | false |
Std.DHashMap.Internal.Raw₀.insertIfNew_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α} {v : β k}, (↑(m₁.insertIfNew k v)).Equiv ↑(m₂.insertIfNew k v) | true |
CategoryTheory.AddMon.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} →
{motive : M.Hom N → Sort u} →
(t : M.Hom N) →
((hom : M.X ⟶ N.X) →
[isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] →... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.inter_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
IsCompact.locallyCompactSpace_of_mem_nhds_of_group | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {K : Set G},
IsCompact K → ∀ {x : G}, K ∈ nhds x → LocallyCompactSpace G | true |
ringChar.of_eq | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] {p : ℕ}, ringChar R = p → CharP R p | true |
WittVector.poly_eq_of_wittPolynomial_bind_eq | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ) [Fact (Nat.Prime p)] (f g : ℕ → MvPolynomial ℕ ℤ),
(∀ (n : ℕ), (MvPolynomial.bind₁ f) (wittPolynomial p ℤ n) = (MvPolynomial.bind₁ g) (wittPolynomial p ℤ n)) → f = g | true |
TwoSidedIdeal.orderIsoIsTwoSided_symm_apply | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : { I // I.IsTwoSided }),
(RelIso.symm TwoSidedIdeal.orderIsoIsTwoSided) I =
have this := ⋯;
(↑I).toTwoSided | true |
IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Ring 𝕜] [NoZeroDivisors 𝕜],
IsPreconnected S → ContinuousOn f S → Set.EqOn (f ^ 2) 1 S → Set.EqOn f 1 S ∨ Set.EqOn f (-1) S | true |
Fin.preimage_natAdd_uIoc_natAdd | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), Fin.natAdd m ⁻¹' Set.uIoc (Fin.natAdd m i) (Fin.natAdd m j) = Set.uIoc i j | true |
FirstOrder.Language.Substructure.closure_induction | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {s : Set M} {p : M → Prop} {x : M},
x ∈ (FirstOrder.Language.Substructure.closure L).toFun s →
(∀ x ∈ s, p x) → (∀ {n : ℕ} (f : L.Functions n), FirstOrder.Language.ClosedUnder f (setOf p)) → p x | true |
String.utf8ByteSize_sliceFrom | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos}, (s.sliceFrom p).utf8ByteSize = s.utf8ByteSize - p.offset.byteIdx | true |
CategoryTheory.CartesianClosed.uncurry | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A X Y : C} →
[inst_2 : CategoryTheory.Closed A] → (Y ⟶ A ⟹ X) → (CategoryTheory.MonoidalCategoryStruct.tensorObj A Y ⟶ X) | true |
Mathlib.Tactic.Conv.Path.ctorElimType | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} → ℕ → Sort (max 1 u) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.