name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux | Mathlib.CategoryTheory.Sites.CoverLifting | {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] →
{G : CategoryTheory.Functor C D} →
{A : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} A] →
{J : CategoryTheory.GrothendieckTopology C} →
{K : CategoryTheory.GrothendieckTopology D} →
[G.IsCocontinuous J K] →
{F : CategoryTheory.Functor Cᵒᵖ A} →
CategoryTheory.Presheaf.IsSheaf J F →
{R : CategoryTheory.Functor Dᵒᵖ A} →
(G.op.comp R ⟶ F) →
{X : D} →
{S : K.Cover X} →
(s : CategoryTheory.Limits.Multifork (S.index R)) →
{Y : C} → (G.obj Y ⟶ X) → (s.pt ⟶ F.obj (Opposite.op Y)) | true |
_private.Mathlib.Condensed.Discrete.LocallyConstant.0.CompHausLike.LocallyConstant.adjunction._proof_2 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : CompHausLike.HasExplicitFiniteCoproducts P] [inst_1 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f))
(X : CategoryTheory.Sheaf (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u_1 u_2))),
CategoryTheory.Preregular (CompHausLike P) →
CategoryTheory.Limits.PreservesFiniteProducts
((CategoryTheory.sheafToPresheaf (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u_1 u_2))).obj X) | false |
groupCohomology.cocycles₁IsoOfIsTrivial._proof_6 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_2, u_1, u_1} k G) [hA : A.IsTrivial]
(x x_1 : ↥(groupCohomology.cocycles₁ A)),
{ toFun := ⇑(x + x_1) ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ } =
{ toFun := ⇑(x + x_1) ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ } | false |
Lean.Parser.Term.arrow.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | true |
isOpen_range_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpen (Set.range (Sigma.mk i)) | true |
definition._@.Mathlib.Topology.FiberBundle.Constructions.1875155857._hygCtx._hyg.8 | Mathlib.Topology.FiberBundle.Constructions | {B : Type u} →
(F : Type v) →
(E : B → Type w₁) →
{B' : Type w₂} →
(f : B' → B) →
[TopologicalSpace B'] →
[TopologicalSpace (Bundle.TotalSpace F E)] → TopologicalSpace (Bundle.TotalSpace F (f *ᵖ E)) | false |
Matrix.toBilin'_apply | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} [inst : CommSemiring R₁] {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix n n R₁) (x y : n → R₁), ((Matrix.toBilin' M) x) y = ∑ i, ∑ j, x i * M i j * y j | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkRichHCongr.withNewEqs | Mathlib.Lean.Meta.CongrTheorems | Lean.Meta.FunInfo →
{α : Type} →
Array Lean.Expr →
Array Lean.Expr →
Array Bool →
(Array Lean.Meta.CongrArgKind → Array (Option (Lean.Expr × Lean.Expr × Lean.Expr)) → Lean.MetaM α) →
Lean.MetaM α | true |
_private.Mathlib.Algebra.Lie.Submodule.0.LieSubmodule.instInfSet._simp_2 | Mathlib.Algebra.Lie.Submodule | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
KaehlerDifferential.isBaseChange | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTower R S B]
[h : Algebra.IsPushout R S A B], IsBaseChange S (↑R (KaehlerDifferential.map R S A B)) | true |
MeasCat.instLargeCategory._proof_5 | Mathlib.MeasureTheory.Category.MeasCat | ∀ {X Y Z : MeasCat} (f : { f // Measurable f }) (g : { f // Measurable f }), Measurable (↑g ∘ ↑f) | false |
Filter.tendsto_neg_atTop_iff._simp_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot | false |
SimplexCategory.δ_one_eq_const | Mathlib.AlgebraicTopology.SimplexCategory.Basic | SimplexCategory.δ 1 = (SimplexCategory.mk 0).const (SimplexCategory.mk (0 + 1)) 0 | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology.0.CochainComplex.HomComplex.CohomologyClass.toHom._simp_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {G : Type u_1} [inst : AddGroup G] {M : Type u_7} [inst_1 : AddZeroClass M] {f : G →+ M} {x : G},
(x ∈ f.ker) = (f x = 0) | false |
Matrix.spectrum_toLpLin | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(p : ENNReal), spectrum 𝕜 ((Matrix.toLpLin p p) A) = spectrum 𝕜 A | true |
Units.instIsManifoldModelWithCornersSelf | Mathlib.Geometry.Manifold.Instances.UnitsOfNormedAlgebra | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R] {n : WithTop ℕ∞} {𝕜 : Type u_2}
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedAlgebra 𝕜 R], IsManifold (modelWithCornersSelf 𝕜 R) n Rˣ | true |
Lean.Meta.DiscrTree.Key.star | Lean.Meta.DiscrTree.Types | Lean.Meta.DiscrTree.Key | true |
FirstOrder.Language.BoundedFormula.listEncode.eq_def | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u'} (x : ℕ) (x_1 : L.BoundedFormula α x),
x_1.listEncode =
match x, x_1 with
| n, FirstOrder.Language.BoundedFormula.falsum => [Sum.inr (Sum.inr (n + 2))]
| x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ => [Sum.inl ⟨x, t₁⟩, Sum.inl ⟨x, t₂⟩]
| n, FirstOrder.Language.BoundedFormula.rel R ts =>
[Sum.inr (Sum.inl ⟨l, R⟩), Sum.inr (Sum.inr n)] ++ List.map (fun i => Sum.inl ⟨n, ts i⟩) (List.finRange l)
| x, φ₁.imp φ₂ => Sum.inr (Sum.inr 0) :: φ₁.listEncode ++ φ₂.listEncode
| x, φ.all => Sum.inr (Sum.inr 1) :: φ.listEncode | true |
MvQPF.WEquiv.below.trans | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W α) → MvQPF.WEquiv a a_1 → Prop} (u v w : (MvQPF.P F).W α) (a : MvQPF.WEquiv u v)
(a_1 : MvQPF.WEquiv v w),
MvQPF.WEquiv.below a → motive u v a → MvQPF.WEquiv.below a_1 → motive v w a_1 → MvQPF.WEquiv.below ⋯ | true |
Multiset.nodup_zero | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1}, Multiset.Nodup 0 | true |
_private.Mathlib.Order.Category.DistLat.0.DistLat.Hom.mk._flat_ctor | Mathlib.Order.Category.DistLat | {X Y : DistLat} → LatticeHom ↑X ↑Y → X.Hom Y | false |
Lean.Server.LoadedILean.refs | Lean.Server.References | Lean.Server.LoadedILean → Lean.Lsp.ModuleRefs | true |
EReal.nhds_top | Mathlib.Topology.Instances.EReal.Lemmas | nhds ⊤ = ⨅ a, ⨅ (_ : a ≠ ⊤), Filter.principal (Set.Ioi a) | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.posGE._unary.eq_def | Init.Data.String.Lemmas.FindPos | ∀ (s : String.Slice) (_x : (offset : String.Pos.Raw) ×' offset ≤ s.rawEndPos),
String.Slice.posGE._unary s _x =
PSigma.casesOn _x fun offset h =>
if h' : String.Pos.Raw.IsValidForSlice s offset then s.pos offset h'
else
have this := ⋯;
String.Slice.posGE._unary s ⟨offset.inc, ⋯⟩ | false |
Std.Time.Database.TZdb | Std.Time.Zoned.Database.TZdb | Type | true |
HomologicalComplex.mkHomFromDouble_f₁ | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X₀ X₁ : C} {f : X₀ ⟶ X₁} {ι : Type u_2} {c : ComplexShape ι}
{i₀ i₁ : ι} (hi₀₁ : c.Rel i₀ i₁) (h : i₀ ≠ i₁) {K : HomologicalComplex C c} (φ₀ : X₀ ⟶ K.X i₀) (φ₁ : X₁ ⟶ K.X i₁)
(comm : CategoryTheory.CategoryStruct.comp φ₀ (K.d i₀ i₁) = CategoryTheory.CategoryStruct.comp f φ₁)
(hφ : ∀ (k : ι), c.Rel i₁ k → CategoryTheory.CategoryStruct.comp φ₁ (K.d i₁ k) = 0),
(HomologicalComplex.mkHomFromDouble hi₀₁ h φ₀ φ₁ comm hφ).f i₁ =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.doubleXIso₁ f hi₀₁ h).hom φ₁ | true |
Lean.Parser.ParserInfo.collectTokens | Lean.Parser.Types | Lean.Parser.ParserInfo → List Lean.Parser.Token → List Lean.Parser.Token | true |
Lean.Meta.State._sizeOf_inst | Lean.Meta.Basic | SizeOf Lean.Meta.State | false |
CategoryTheory.Presieve.FamilyOfElements.Compatible.to_sieveCompatible | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
{S : CategoryTheory.Sieve X} {x : CategoryTheory.Presieve.FamilyOfElements P S.arrows},
x.Compatible → x.SieveCompatible | true |
isInteger_of_is_root_of_monic | Mathlib.RingTheory.Polynomial.RationalRoot | ∀ {A : Type u_1} {K : Type u_2} [inst : CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [inst_3 : Field K]
[inst_4 : Algebra A K] [IsFractionRing A K] {p : Polynomial A},
p.Monic → ∀ {r : K}, (Polynomial.aeval r) p = 0 → IsLocalization.IsInteger A r | true |
TopCat.Presheaf.toPushforwardOfIso_app._proof_1 | Mathlib.Topology.Sheaves.Presheaf | ∀ {X Y : TopCat} (H₁ : X ≅ Y) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ),
U =
(TopologicalSpace.Opens.map H₁.hom).op.obj (Opposite.op ((TopologicalSpace.Opens.map H₁.inv).obj (Opposite.unop U))) | false |
AddUnits.instAddCommGroupAddUnits | Mathlib.Algebra.Group.Units.Defs | {α : Type u_1} → [inst : AddCommMonoid α] → AddCommGroup (AddUnits α) | true |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.Even.0.CliffordAlgebra.even.lift.fFold._proof_8 | Mathlib.LinearAlgebra.CliffordAlgebra.Even | ∀ {R : Type u_3} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {A : Type u_1} [inst_3 : Ring A] [inst_4 : Algebra R A] (f : CliffordAlgebra.EvenHom Q A)
(x : M) (x_1 x_2 : A × ↥(CliffordAlgebra.even.lift.S✝ f)),
(↑(x_1 + x_2).2 x, ⟨LinearMap.mulRight R (x_1 + x_2).1 ∘ₗ f.bilin.flip x, ⋯⟩) =
(↑x_1.2 x, ⟨LinearMap.mulRight R x_1.1 ∘ₗ f.bilin.flip x, ⋯⟩) +
(↑x_2.2 x, ⟨LinearMap.mulRight R x_2.1 ∘ₗ f.bilin.flip x, ⋯⟩) | false |
Std.DTreeMap.Internal.Impl.get?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.LawfulEqOrd α] (k : α),
Std.DTreeMap.Internal.Impl.leaf.get? k = none | true |
_private.Mathlib.Topology.Algebra.Group.Matrix.0.Matrix.SpecialLinearGroup.range_toGL.match_1_2 | Mathlib.Topology.Algebra.Group.Matrix | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {A : Type u_2} [inst_2 : CommRing A] (x : GL n A)
(motive : (∃ y, ↑y = ↑x) → Prop) (x_1 : ∃ y, ↑y = ↑x),
(∀ (y : Matrix.SpecialLinearGroup n A) (hy : ↑y = ↑x), motive ⋯) → motive x_1 | false |
Real.exists_seq_rat_strictAnti_tendsto | Mathlib.Topology.Instances.Real.Lemmas | ∀ (x : ℝ), ∃ u, StrictAnti u ∧ (∀ (n : ℕ), x < ↑(u n)) ∧ Filter.Tendsto (fun x => ↑(u x)) Filter.atTop (nhds x) | true |
PadicInt.intCast_eq | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (z1 z2 : ℤ), ↑z1 = ↑z2 ↔ z1 = z2 | true |
List.le_apply_get_maxOn?_of_mem | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β}
{xs : List α} {x : α} (h : x ∈ xs), f x ≤ f ((List.maxOn? f xs).get ⋯) | true |
OrderIso.sumLexAssoc_apply_inl_inr | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] [inst_2 : LE γ] (b : β),
(OrderIso.sumLexAssoc α β γ) (toLex (Sum.inl (toLex (Sum.inr b)))) = toLex (Sum.inr (toLex (Sum.inl b))) | true |
GrpCat.SurjectiveOfEpiAuxs.g_apply_fromCoset | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B) (x : ↑B) (y : ↑(Set.range fun x => x • ↑(GrpCat.Hom.hom f).range)),
((GrpCat.SurjectiveOfEpiAuxs.g f) x) (GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset y) =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨x • ↑y, ⋯⟩ | true |
integral_log | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ}, ∫ (s : ℝ) in a..b, Real.log s = b * Real.log b - a * Real.log a - b + a | true |
CategoryTheory.FreeMonoidalCategory.Hom.ctorElim | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
(ctorIdx : ℕ) →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
ctorIdx = t.ctorIdx → CategoryTheory.FreeMonoidalCategory.Hom.ctorElimType ctorIdx → motive a a_1 t | false |
Aesop.PremiseIndex._sizeOf_inst | Aesop.Forward.PremiseIndex | SizeOf Aesop.PremiseIndex | false |
SeparationQuotient.instNonAssocRing._proof_11 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocRing R] [inst_2 : IsTopologicalRing R] (x : R),
SeparationQuotient.mk (-x) = -SeparationQuotient.mk x | false |
ModuleCat.exteriorPower.functor | Mathlib.Algebra.Category.ModuleCat.ExteriorPower | (R : Type u) → [inst : CommRing R] → ℕ → CategoryTheory.Functor (ModuleCat R) (ModuleCat R) | true |
sSupIndep_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_5} [inst : CompleteLattice α] (s : Set α), sSupIndep s ↔ iSupIndep Subtype.val | true |
Aesop.GoalState.ctorIdx | Aesop.Tree.Data | Aesop.GoalState → ℕ | false |
unexpandMkArray0 | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | true |
Lean.Elab.Tactic.evalWithReducible | Lean.Elab.Tactic.ElabTerm | Lean.Elab.Tactic.Tactic | true |
Submonoid.mem_closure_pair | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_4} [inst : CommMonoid A] (a b c : A), c ∈ Submonoid.closure {a, b} ↔ ∃ m n, a ^ m * b ^ n = c | true |
BooleanRing.sup_comm | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a b : α), a ⊔ b = b ⊔ a | true |
CategoryTheory.SmallObject.functorMapTgt.eq_1 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i)
{S T X Y : C} {πX : X ⟶ S} {πY : Y ⟶ T} (τ : CategoryTheory.Arrow.mk πX ⟶ CategoryTheory.Arrow.mk πY)
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX))
C]
[inst_2 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY))
C],
CategoryTheory.SmallObject.functorMapTgt f τ =
CategoryTheory.Limits.Sigma.map'
(fun x =>
{ i := x.i, t := CategoryTheory.CategoryStruct.comp x.t τ.left,
b := CategoryTheory.CategoryStruct.comp x.b τ.right, w := ⋯ })
fun x => CategoryTheory.CategoryStruct.id (CategoryTheory.SmallObject.functorObjTgtFamily f πX x) | true |
IsLocalDiffeomorphAt.mfderivToContinuousLinearEquiv._proof_2 | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_4}
[inst_5 : TopologicalSpace H] {G : Type u_6} [inst_6 : TopologicalSpace G] {I : ModelWithCorners 𝕜 E H}
{J : ModelWithCorners 𝕜 F G} {M : Type u_5} [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace H M] {N : Type u_7}
[inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace G N] {n : WithTop ℕ∞} {f : M → N} {x : M}
(hf : IsLocalDiffeomorphAt I J n f x),
n ≠ 0 → Function.LeftInverse ⇑(mfderiv% ↑hf.localInverse.toPartialEquiv (f x)) ⇑(mfderiv% f x) | false |
Action.Functor.mapActionPreservesLimitsOfShapeOfPreserves | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_3}
[inst_1 : CategoryTheory.Category.{v_2, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [inst_2 : Monoid G]
{J : Type u_5} [inst_3 : CategoryTheory.Category.{v_3, u_5} J] [CategoryTheory.Limits.PreservesLimitsOfShape J F]
[CategoryTheory.Limits.HasLimitsOfShape J V], CategoryTheory.Limits.PreservesLimitsOfShape J (F.mapAction G) | true |
Lean.Compiler.InlineAttributeKind.alwaysInline.sizeOf_spec | Lean.Compiler.InlineAttrs | sizeOf Lean.Compiler.InlineAttributeKind.alwaysInline = 1 | true |
partialFunToPointed._proof_4 | Mathlib.CategoryTheory.Category.PartialFun | ∀ (X : PartialFun),
Option.elim' none (fun a => (CategoryTheory.CategoryStruct.id X a).toOption) { X := Option X, point := none }.point =
Option.elim' none (fun a => (CategoryTheory.CategoryStruct.id X a).toOption) { X := Option X, point := none }.point | false |
NatPow.casesOn | Init.Prelude | {α : Type u} → {motive : NatPow α → Sort u_1} → (t : NatPow α) → ((pow : α → ℕ → α) → motive { pow := pow }) → motive t | false |
Std.DHashMap.Const.mem_unitOfList._simp_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α} {k : α},
(k ∈ Std.DHashMap.Const.unitOfList l) = (l.contains k = true) | false |
CategoryTheory.Bicategory.eqToHom_whiskerRight | Mathlib.CategoryTheory.Bicategory.Strict.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g : a ⟶ b} (η : f = g) (h : b ⟶ c),
CategoryTheory.Bicategory.whiskerRight (CategoryTheory.eqToHom η) h = CategoryTheory.eqToHom ⋯ | true |
Filter.Germ.instLinearOrder | Mathlib.Order.Filter.FilterProduct | {α : Type u} → {β : Type v} → {φ : Ultrafilter α} → [LinearOrder β] → LinearOrder ((↑φ).Germ β) | true |
AsBoolAlg | Mathlib.Algebra.Ring.BooleanRing | Type u_4 → Type u_4 | true |
_private.Mathlib.Topology.Sheaves.Flasque.0.TopCat.Sheaf.IsFlasque.epi_of_shortExact.match_1_7.eq_2 | Mathlib.Topology.Sheaves.Flasque | ∀ (motive : Fin 2 → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()) =
h_2 () | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.instHashablePurity.hash.match_1 | Lean.Compiler.LCNF.Basic | (motive : Lean.Compiler.LCNF.Purity → Sort u_1) →
(x : Lean.Compiler.LCNF.Purity) →
(Unit → motive Lean.Compiler.LCNF.Purity.pure) → (Unit → motive Lean.Compiler.LCNF.Purity.impure) → motive x | false |
isClopen_range_inr | Mathlib.Topology.Clopen | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], IsClopen (Set.range Sum.inr) | true |
Set.Nontrivial.not_subsingleton | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} {s : Set α}, s.Nontrivial → ¬s.Subsingleton | true |
Computation.Results.terminates | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ}, s.Results a n → s.Terminates | true |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun._unsafe_rec | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | (𝕜 : Type u_2) →
{α : Type u_5} →
[AddCommGroup 𝕜] → [One 𝕜] → [inst : Preorder α] → [LocallyFiniteOrder α] → [DecidableEq α] → α → α → 𝕜 | false |
Finset.union_val_nd | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∪ t).val = s.val.ndunion t.val | true |
AddCommute.zsmul_add | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, AddCommute a b → ∀ (n : ℤ), n • (a + b) = n • a + n • b | true |
Lean.Compiler.LCNF.inScope | Lean.Compiler.LCNF.MonadScope | {m : Type → Type} → [Lean.Compiler.LCNF.MonadScope m] → [Monad m] → Lean.FVarId → m Bool | true |
HasStrictFDerivAt.cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f g : E → ℂ} {f' g' : StrongDual ℂ E}
{x : E},
HasStrictFDerivAt f f' x →
HasStrictFDerivAt g g' x →
f x ∈ Complex.slitPlane →
HasStrictFDerivAt (fun x => f x ^ g x) ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log (f x)) • g') x | true |
TopCat.Presheaf.pushforwardEq_hom_app._proof_2 | Mathlib.Topology.Sheaves.Presheaf | ∀ {X Y : TopCat} {f g : X ⟶ Y},
f = g →
∀ (U : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
(TopologicalSpace.Opens.map f).op.obj U = (TopologicalSpace.Opens.map g).op.obj U | false |
PreconnectedSpace.rec | Mathlib.Topology.Connected.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{motive : PreconnectedSpace α → Sort u_1} →
((isPreconnected_univ : IsPreconnected Set.univ) → motive ⋯) → (t : PreconnectedSpace α) → motive t | false |
Mathlib.Tactic.Sat.Clause.mk.injEq | Mathlib.Tactic.Sat.FromLRAT | ∀ (lits : Array ℤ) (expr proof : Lean.Expr) (lits_1 : Array ℤ) (expr_1 proof_1 : Lean.Expr),
({ lits := lits, expr := expr, proof := proof } = { lits := lits_1, expr := expr_1, proof := proof_1 }) =
(lits = lits_1 ∧ expr = expr_1 ∧ proof = proof_1) | true |
Function.Injective.isMulTorsionFree | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : Monoid N] [IsMulTorsionFree N] (f : M →* N),
Function.Injective ⇑f → IsMulTorsionFree M | true |
HomogeneousLocalization.NumDenSameDeg.instNeg._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_3} {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [NegMemClass σ A] {𝒜 : ι → σ}
(x : Submonoid A) (c : HomogeneousLocalization.NumDenSameDeg 𝒜 x), -↑c.num ∈ 𝒜 c.deg | false |
CategoryTheory.Adjunction.coconesIsoComponentInv._proof_1 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] {K : CategoryTheory.Functor J C} (Y : D)
(t : (G.comp ((CategoryTheory.cocones J C).obj (Opposite.op K))).obj Y) (j j' : J) (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp ((Opposite.unop (Opposite.op (Opposite.unop (Opposite.op (K.comp F))))).map f)
((adj.homEquiv (K.obj j') Y).symm (t.app j')) =
CategoryTheory.CategoryStruct.comp ((adj.homEquiv (K.obj j) Y).symm (t.app j))
(((CategoryTheory.Functor.const J).obj Y).map f) | false |
Function.RightInverse.filter_map | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α},
Function.RightInverse g f → Function.RightInverse (Filter.map g) (Filter.map f) | true |
GradedRingHom.coe_mul | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_6} [inst : Semiring A] [inst_1 : SetLike σ A] {𝒜 : ι → σ} (f g : 𝒜 →+*ᵍ 𝒜),
⇑(f * g) = ⇑f ∘ ⇑g | true |
Submodule.toAddSubmonoid_injective | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Function.Injective Submodule.toAddSubmonoid | true |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.iSupIndep_iff_supIndep_of_injOn._simp_1_6 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Finset β} {hf : Set.InjOn f (f ⁻¹' ↑s)} {x : α},
(x ∈ s.preimage f hf) = (f x ∈ s) | false |
CochainComplex.πTruncGE_naturality_assoc | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : ∀ (i : ℤ), HomologicalComplex.HasHomology K i] [inst_4 : ∀ (i : ℤ), HomologicalComplex.HasHomology L i]
(n : ℤ) {Z : CochainComplex C ℤ} (h : L.truncGE n ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.πTruncGE n)
(CategoryTheory.CategoryStruct.comp (CochainComplex.truncGEMap φ n) h) =
CategoryTheory.CategoryStruct.comp φ (CategoryTheory.CategoryStruct.comp (L.πTruncGE n) h) | true |
List.sublists'.eq_1 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} (l : List α),
l.sublists' = (List.foldr (fun a arr => Array.foldl (fun r l => r.push (a :: l)) arr arr) #[[]] l).toList | true |
Measurable.sinh | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ℝ}, Measurable f → Measurable fun x => Real.sinh (f x) | true |
fst_himp | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : HImp α] [inst_1 : HImp β] (a b : α × β), (a ⇨ b).1 = a.1 ⇨ b.1 | true |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instOrdRefIdent.ord.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 : String) → (x : Lean.Lsp.RefIdent) → motive (Lean.Lsp.RefIdent.const a a_1) x) →
((x : Lean.Lsp.RefIdent) → (a a_1 : String) → motive x (Lean.Lsp.RefIdent.const a a_1)) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.fvar a a_1) (Lean.Lsp.RefIdent.fvar b b_1)) → motive x x_1 | false |
Nat.mod_four_ne_three_of_mem_primeFactors_of_isSquare_neg_one | Mathlib.NumberTheory.SumTwoSquares | ∀ {p n : ℕ}, p ∈ n.primeFactors → IsSquare (-1) → p % 4 ≠ 3 | true |
IsAddUnit.add_neg_cancel_left | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : SubtractionMonoid α] {a : α}, IsAddUnit a → ∀ (b : α), a + (-a + b) = b | true |
IO.instReprTaskState.repr | Init.System.IO | IO.TaskState → ℕ → Std.Format | true |
Real.Angle.cos_eq_iff_eq_or_eq_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ ψ : Real.Angle}, θ.cos = ψ.cos ↔ θ = ψ ∨ θ = -ψ | true |
_private.Lean.Elab.Tactic.Do.VCGen.0.Lean.Elab.Tactic.Do.VCGen.genVCs.assignMVars | Lean.Elab.Tactic.Do.VCGen | List Lean.MVarId → Lean.Elab.Tactic.Do.VCGenM PUnit.{1} | true |
BitVec.reverse_append._proof_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, v + w = w + v | false |
Std.ExtDHashMap.mem_insert | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k}, a ∈ m.insert k v ↔ (k == a) = true ∨ a ∈ m | true |
AddValuation.comap_comp | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{S₁ : Type u_6} {S₂ : Type u_7} [inst_2 : Ring S₁] [inst_3 : Ring S₂] (f : S₁ →+* S₂) (g : S₂ →+* R),
AddValuation.comap (g.comp f) v = AddValuation.comap f (AddValuation.comap g v) | true |
QuadraticAlgebra.imₗ._proof_2 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R] (x : R) (x_1 : QuadraticAlgebra R a b), (x • x_1).im = (x • x_1).im | false |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRoi.decEq._proof_2 | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u_1} (a b : α), ¬a = b → a<...* = b<...* → False | false |
_private.Mathlib.LinearAlgebra.UnitaryGroup.0.Matrix.kroneckerTMul_mem_unitary._simp_1_1 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | false |
BitVec.instOrOp | Init.Data.BitVec.Basic | {w : ℕ} → OrOp (BitVec w) | true |
Representation.IntertwiningMap.instSMulInt | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
{V : Type u_6} →
{W : Type u_7} →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
(ρ : Representation A G V) → (σ : Representation A G W) → SMul ℤ (ρ.IntertwiningMap σ) | true |
Lean.Grind.AC.Seq.beq'_eq | Init.Grind.AC | ∀ (s₁ s₂ : Lean.Grind.AC.Seq), (s₁.beq' s₂ = true) = (s₁ = s₂) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.