name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.OverClass.asOverHom_comp | Mathlib.CategoryTheory.Comma.Over.OverClass | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (S : C) [inst_1 : CategoryTheory.OverClass X S]
[inst_2 : CategoryTheory.OverClass Y S] [inst_3 : CategoryTheory.OverClass Z S] (f : X ⟶ Y) (g : Y ⟶ Z)
[inst_4 : CategoryTheory.HomIsOver f S] [inst_5 : CategoryTheory.HomIsOver g S],
CategoryTheory.OverClass.asOverHom S (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.OverClass.asOverHom S f) (CategoryTheory.OverClass.asOverHom S g) | true |
Aesop.BaseM.instMonadHashMapCacheAdapterExprEntry | Aesop.BaseM | Lean.MonadHashMapCacheAdapter Lean.Expr Aesop.RulePatternCache.Entry Aesop.BaseM | true |
FourierInvModule.mk.inj | Mathlib.Analysis.Fourier.Notation | ∀ {R : Type u_5} {E : Type u_6} {F : outParam (Type u_7)} {inst : Add E} {inst_1 : Add F} {inst_2 : SMul R E}
{inst_3 : SMul R F} {toFourierTransformInv : FourierTransformInv E F}
{fourierInv_add :
∀ (f g : E),
FourierTransformInv.fourierInv (f + g) = FourierTransformInv.fourierInv f + FourierTransformInv.fourierInv g}
{fourierInv_smul : ∀ (r : R) (f : E), FourierTransformInv.fourierInv (r • f) = r • FourierTransformInv.fourierInv f}
{toFourierTransformInv_1 : FourierTransformInv E F}
{fourierInv_add_1 :
∀ (f g : E),
FourierTransformInv.fourierInv (f + g) = FourierTransformInv.fourierInv f + FourierTransformInv.fourierInv g}
{fourierInv_smul_1 :
∀ (r : R) (f : E), FourierTransformInv.fourierInv (r • f) = r • FourierTransformInv.fourierInv f},
{ toFourierTransformInv := toFourierTransformInv, fourierInv_add := fourierInv_add,
fourierInv_smul := fourierInv_smul } =
{ toFourierTransformInv := toFourierTransformInv_1, fourierInv_add := fourierInv_add_1,
fourierInv_smul := fourierInv_smul_1 } →
toFourierTransformInv = toFourierTransformInv_1 | true |
BigOperators.delabFinsetExpect | Mathlib.Algebra.BigOperators.Expect | Lean.PrettyPrinter.Delaborator.Delab | true |
Std.TreeMap.getElem!_alter | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k k' : α}
[inst : Inhabited β] {f : Option β → Option β},
(t.alter k f)[k']! = if cmp k k' = Ordering.eq then (f t[k]?).get! else t[k']! | true |
_private.Mathlib.Data.Vector3.0.Vector3.eq_nil.match_1_1 | Mathlib.Data.Vector3 | ∀ (motive : Fin2 0 → Prop) (i : Fin2 0), motive i | false |
AddMonoidAlgebra.lift_mapRangeRingHom_algebraMap | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : AddMonoid M]
[inst_2 : Semiring A] [inst_3 : Algebra R A] [inst_4 : CommSemiring S] [inst_5 : Algebra S A] [inst_6 : Algebra R S]
[IsScalarTower R S A] (f : Multiplicative M →* A) (x : AddMonoidAlgebra R M),
((AddMonoidAlgebra.lift S A M) f) ((AddMonoidAlgebra.mapRingHom M (algebraMap R S)) x) =
((AddMonoidAlgebra.lift R A M) f) x | true |
MvPowerSeries.nat_le_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R} {n : ℕ},
(∀ (d : σ →₀ ℕ), (Finsupp.weight w) d < n → (MvPowerSeries.coeff d) f = 0) → ↑n ≤ MvPowerSeries.weightedOrder w f | true |
CategoryTheory.CategoryOfElements.instHasInitialElementsOppositeOfIsRepresentable | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
[F.IsRepresentable], CategoryTheory.Limits.HasInitial F.Elements | true |
SzemerediRegularity.card_eq_of_mem_parts_chunk | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {s : Finset α},
s ∈ (SzemerediRegularity.chunk hP G ε hU).parts →
s.card = Fintype.card α / SzemerediRegularity.stepBound P.parts.card ∨
s.card = Fintype.card α / SzemerediRegularity.stepBound P.parts.card + 1 | true |
CategoryTheory.CosimplicialObject.Augmented.const_obj_hom | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.CosimplicialObject.Augmented.const.obj X).hom =
CategoryTheory.CategoryStruct.id ((CategoryTheory.CosimplicialObject.const C).obj X) | true |
_private.Init.Control.State.0.ForM.forIn.match_3 | Init.Control.State | {β : Type u_1} →
(motive : Except β (PUnit.{u_1 + 1} × β) → Sort u_2) →
(__do_lift : Except β (PUnit.{u_1 + 1} × β)) →
((a : PUnit.{u_1 + 1} × β) → motive (Except.ok a)) → ((a : β) → motive (Except.error a)) → motive __do_lift | false |
IsHomeomorph.toEquiv_homeomorph | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y)
(hf : IsHomeomorph f), (IsHomeomorph.homeomorph f hf).toEquiv = Equiv.ofBijective f ⋯ | true |
Num.decidablePrime | Mathlib.Data.Num.Prime | DecidablePred Num.Prime | true |
Prod.toSigma_inj._simp_1 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_7} {β : Type u_8} {x y : α × β}, (x.toSigma = y.toSigma) = (x = y) | false |
StandardSubspace.toClosedSubmodule_inj._simp_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] {S T : StandardSubspace H},
(S.toClosedSubmodule = T.toClosedSubmodule) = (S = T) | false |
CategoryTheory.Over.iteratedSliceBackward | Mathlib.CategoryTheory.Comma.Over.Basic | {T : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} T] →
{X : T} → (f : CategoryTheory.Over X) → CategoryTheory.Functor (CategoryTheory.Over f.left) (CategoryTheory.Over f) | true |
SeminormedRing.mk._flat_ctor | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
(norm : α → ℝ) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ℕ) (x : α), nsmul (n + 1) x = nsmul n x + x) AddMonoid.nsmul_succ._autoParam →
(∀ (a b : α), a + b = b + a) →
(mul : α → α → α) →
(∀ (a b c : α), a * (b + c) = a * b + a * c) →
(∀ (a b c : α), (a + b) * c = a * c + b * c) →
(∀ (a : α), 0 * a = 0) →
(∀ (a : α), a * 0 = 0) →
(∀ (a b c : α), a * b * c = a * (b * c)) →
(one : α) →
(∀ (a : α), 1 * a = a) →
(∀ (a : α), a * 1 = a) →
(natCast : ℕ → α) →
autoParam (natCast 0 = 0) AddMonoidWithOne.natCast_zero._autoParam →
autoParam (∀ (n : ℕ), natCast (n + 1) = natCast n + 1)
AddMonoidWithOne.natCast_succ._autoParam →
(npow : ℕ → α → α) →
autoParam (∀ (x : α), npow 0 x = 1) Monoid.npow_zero._autoParam →
autoParam (∀ (n : ℕ) (x : α), npow (n + 1) x = npow n x * x)
Monoid.npow_succ._autoParam →
(neg : α → α) →
(sub : α → α → α) →
autoParam (∀ (a b : α), a - b = a + neg b)
SubNegMonoid.sub_eq_add_neg._autoParam →
(zsmul : ℤ → α → α) →
autoParam (∀ (a : α), zsmul 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam →
autoParam
(∀ (n : ℕ) (a : α),
zsmul (↑n.succ) a = zsmul (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam →
autoParam
(∀ (n : ℕ) (a : α),
zsmul (Int.negSucc n) a = neg (zsmul (↑n.succ) a))
SubNegMonoid.zsmul_neg'._autoParam →
(∀ (a : α), neg a + a = 0) →
(intCast : ℤ → α) →
autoParam (∀ (n : ℕ), intCast ↑n = ↑n)
AddGroupWithOne.intCast_ofNat._autoParam →
autoParam
(∀ (n : ℕ),
intCast (Int.negSucc n) = neg ↑(n + 1))
AddGroupWithOne.intCast_negSucc._autoParam →
(dist : α → α → ℝ) →
(∀ (x : α), dist x x = 0) →
(∀ (x y : α), dist x y = dist y x) →
(∀ (x y z : α),
dist x z ≤ dist x y + dist y z) →
(edist : α → α → ENNReal) →
autoParam
(∀ (x y : α),
edist x y =
ENNReal.ofReal (dist x y))
PseudoMetricSpace.edist_dist._autoParam →
(toUniformSpace :
UniformSpace α) →
autoParam
(uniformity α =
⨅ ε,
⨅ (_ : ε > 0),
Filter.principal
{p |
dist p.1 p.2 < ε})
PseudoMetricSpace.uniformity_dist._autoParam →
(toBornology : Bornology α) →
autoParam
((Bornology.cobounded
α).sets =
{s | ⋯})
PseudoMetricSpace.cobounded_sets._autoParam →
(∀ (x y : α),
dist x y =
norm (neg x + y)) →
(∀ (a b : α),
norm (a * b) ≤
norm a * norm b) →
SeminormedRing α | false |
CategoryTheory.Functor.PushoutObjObj.ι.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₂ Y₂ : C₂} {f₂ : X₂ ⟶ Y₂}
(sq : F.PushoutObjObj f₁ f₂), sq.ι = ⋯.desc ((F.obj Y₁).map f₂) ((F.map f₁).app Y₂) ⋯ | true |
CategoryTheory.Functor.IsLocallyFull.recOn | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | {C : Type uC} →
[inst : CategoryTheory.Category.{vC, uC} C] →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{vD, uD} D] →
{G : CategoryTheory.Functor C D} →
{K : CategoryTheory.GrothendieckTopology D} →
{motive : G.IsLocallyFull K → Sort u} →
(t : G.IsLocallyFull K) →
((functorPushforward_imageSieve_mem :
∀ {U V : C} (f : G.obj U ⟶ G.obj V),
CategoryTheory.Sieve.functorPushforward G (G.imageSieve f) ∈ K (G.obj U)) →
motive ⋯) →
motive t | false |
HomologicalComplex.IsStrictlySupportedOutside.mk._flat_ctor | Mathlib.Algebra.Homology.Embedding.IsSupported | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : HomologicalComplex C c'} {e : c.Embedding c'},
(∀ (i : ι), CategoryTheory.Limits.IsZero (K.X (e.f i))) → K.IsStrictlySupportedOutside e | false |
Std.DTreeMap.Internal.Impl.getKeyD_minKey | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {he : t.isEmpty = false} {fallback : α}, t.getKeyD (t.minKey he) fallback = t.minKey he | true |
Codisjoint.sup_right | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α} (c : α),
Codisjoint a b → Codisjoint a (b ⊔ c) | true |
_private.Mathlib.Combinatorics.Enumerative.Schroder.0.Nat.smallSchroder.match_1.eq_1 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ => h_3 n) =
h_1 () | true |
Std.IsPartialOrder.of_le | Init.Data.Order.Factories | ∀ {α : Type u} [inst : LE α],
autoParam (Std.Refl fun x1 x2 => x1 ≤ x2) Std.IsPartialOrder.of_le._auto_1 →
autoParam (Std.Antisymm fun x1 x2 => x1 ≤ x2) Std.IsPartialOrder.of_le._auto_3 →
∀
(le_trans :
autoParam (Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2)
Std.IsPartialOrder.of_le._auto_5),
Std.IsPartialOrder α | true |
Lean.SubExpr.Pos | Lean.SubExpr | Type | true |
padicNorm_two_harmonic | Mathlib.NumberTheory.Harmonic.Int | ∀ {n : ℕ}, n ≠ 0 → ‖↑(harmonic n)‖ = 2 ^ Nat.log 2 n | true |
List.length_take_le' | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} (i : ℕ) (l : List α), (List.take i l).length ≤ l.length | true |
WithZero.coe_expEquiv_apply | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {G : Type u_5} [inst : AddGroup G] (a : G), ↑(WithZero.expEquiv a) = WithZero.exp a | true |
Function.Embedding.trans_arrowCongrLeft | Mathlib.Logic.Embedding.Basic | ∀ {α₁ : Sort u} {α₂ : Sort v} {α₃ : Sort x} {γ : Sort w} [inst : Inhabited γ] (e₁₂ : α₁ ↪ α₂) (e₂₃ : α₂ ↪ α₃),
e₁₂.arrowCongrLeft.trans e₂₃.arrowCongrLeft = (e₁₂.trans e₂₃).arrowCongrLeft | true |
leansearchclient.backend | LeanSearchClient.Basic | Lean.Option String | true |
ModelWithCorners._sizeOf_1 | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : 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} → [SizeOf 𝕜] → [SizeOf E] → [SizeOf H] → ModelWithCorners 𝕜 E H → ℕ | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.equivMapDomain._simp_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_9} {M : Type u_10} [inst : Zero M] (self : α →₀ M) (a : α), (a ∈ self.support) = (self.toFun a ≠ 0) | false |
_private.Init.Data.String.Slice.0.String.Slice.lines.lineMap.match_1 | Init.Data.String.Slice | (motive : Option String.Slice → Sort u_1) →
(x : Option String.Slice) → ((s : String.Slice) → motive (some s)) → ((x : Option String.Slice) → motive x) → motive x | false |
Complex.tan_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.tan ↑x).im = 0 | true |
Aesop.Frontend.Priority.ctorIdx | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority → ℕ | false |
ContinuousLinearMap.ring_lmap_equiv_selfₗ._proof_3 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 →L[𝕜] E), (ContinuousLinearMap.id 𝕜 𝕜).smulRight ((fun f => f 1) f) = f | false |
Std.DTreeMap.Internal.Impl.containsThenInsertIfNew!.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (v : β k) (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.containsThenInsertIfNew! k v t =
if Std.DTreeMap.Internal.Impl.contains k t = true then (true, t)
else (false, Std.DTreeMap.Internal.Impl.insert! k v t) | true |
Module.preReflection | Mathlib.LinearAlgebra.Reflection | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → M → Module.Dual R M → Module.End R M | true |
Lean.Compiler.LCNF.InferType.Pure.inferAppType._unsafe_rec | Lean.Compiler.LCNF.InferType | Lean.Expr → Lean.Compiler.LCNF.InferType.Pure.InferTypeM Lean.Expr | false |
instLawfulCommIdentityUInt16HXorOfNat | Init.Data.UInt.Bitwise | Std.LawfulCommIdentity (fun x1 x2 => x1 ^^^ x2) 0 | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.H2π_eq_zero_iff._simp_1_5 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.ShortComplex.leftHomologyMap' e.inv h₂ h₁ =
(CategoryTheory.ShortComplex.leftHomologyMapIso' e h₁ h₂).inv | false |
FirstOrder.Language.ClosedUnder.sInf | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {n : ℕ} {f : L.Functions n} {S : Set (Set M)},
(∀ s ∈ S, FirstOrder.Language.ClosedUnder f s) → FirstOrder.Language.ClosedUnder f (sInf S) | true |
Infinite.of_not_fintype | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1}, (∀ (a : Fintype α), False) → Infinite α | true |
Lean.Meta.ApplyNewGoals.recOn | Init.Meta.Defs | {motive : Lean.Meta.ApplyNewGoals → Sort u} →
(t : Lean.Meta.ApplyNewGoals) →
motive Lean.Meta.ApplyNewGoals.nonDependentFirst →
motive Lean.Meta.ApplyNewGoals.nonDependentOnly → motive Lean.Meta.ApplyNewGoals.all → motive t | false |
Rep.resFunctor._proof_3 | Mathlib.RepresentationTheory.Rep.Res | ∀ {k : Type u_2} [inst : CommRing k] {G : Type u_3} {H : Type u_4} [inst_1 : Monoid G] [inst_2 : Monoid H] (f : H →* G)
{X Y Z : Rep.{u_1, u_2, u_3} k G} (f_1 : X ⟶ Y) (g : Y ⟶ Z),
Rep.ofHom { toLinearMap := ↑(Rep.Hom.hom (CategoryTheory.CategoryStruct.comp f_1 g)), isIntertwining' := ⋯ } =
CategoryTheory.CategoryStruct.comp (Rep.ofHom { toLinearMap := ↑(Rep.Hom.hom f_1), isIntertwining' := ⋯ })
(Rep.ofHom { toLinearMap := ↑(Rep.Hom.hom g), isIntertwining' := ⋯ }) | false |
TwoSidedIdeal.finsetProd_mem | Mathlib.RingTheory.TwoSidedIdeal.BigOperators | ∀ {R : Type u_1} [inst : CommRing R] (I : TwoSidedIdeal R) {ι : Type u_2} (s : Finset ι) (f : ι → R),
(∃ x ∈ s, f x ∈ I) → s.prod f ∈ I | true |
TrivSqZeroExt.inl_neg | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} (M : Type v) [inst : Neg R] [inst_1 : NegZeroClass M] (r : R),
TrivSqZeroExt.inl (-r) = -TrivSqZeroExt.inl r | true |
CategoryTheory.Limits.IsLimit.binaryFanSwap._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y}
(I : CategoryTheory.Limits.IsLimit s) (t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair Y X))
(j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp (I.lift (CategoryTheory.Limits.BinaryFan.swap t)) (s.swap.π.app j) = t.π.app j | false |
NumberField.mixedEmbedding.polarSpaceCoord.eq_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.polarSpaceCoord K =
(NumberField.mixedEmbedding.polarCoord K).transHomeomorph
(NumberField.mixedEmbedding.homeoRealMixedSpacePolarSpace K) | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.ker_eval₂Hom_universalFactorizationMap._simp_1_4 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * c - b * c = (a - b) * c | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt16.reduceGE.declare_127._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.211 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.processAssignmentFOApprox.loop | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Lean.Expr → Lean.MetaM Bool | true |
Std.DTreeMap.maxKeyD_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β k}
{fallback : α}, (t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | true |
CategoryTheory.instInhabitedMkId | Mathlib.CategoryTheory.Category.KleisliCat | {α : Type u} → [Inhabited α] → Inhabited (CategoryTheory.KleisliCat.mk id α) | true |
CategoryTheory.ProjectiveResolution.homotopyEquiv_inv_π_assoc | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(P Q : CategoryTheory.ProjectiveResolution X) {Z : HomologicalComplex C (ComplexShape.down ℕ)}
(h : (ChainComplex.single₀ C).obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp (P.homotopyEquiv Q).inv (CategoryTheory.CategoryStruct.comp P.π h) =
CategoryTheory.CategoryStruct.comp Q.π h | true |
ContinuousLinearEquiv.isAddHaarMeasure_map | Mathlib.MeasureTheory.Group.Measure | ∀ {E : Type u_3} {F : Type u_4} {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommGroup E] [inst_3 : Module R E] [inst_4 : AddCommGroup F] [inst_5 : Module S F]
[inst_6 : TopologicalSpace E] [IsTopologicalAddGroup E] [inst_8 : TopologicalSpace F] [IsTopologicalAddGroup F]
{σ : R →+* S} {σ' : S →+* R} [inst_10 : RingHomInvPair σ σ'] [inst_11 : RingHomInvPair σ' σ]
[inst_12 : MeasurableSpace E] [BorelSpace E] [inst_14 : MeasurableSpace F] [BorelSpace F] (L : E ≃SL[σ] F)
(μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure], (MeasureTheory.Measure.map (⇑L) μ).IsAddHaarMeasure | true |
SemiRingCat.hom_ext | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : SemiRingCat} {f g : R ⟶ S}, SemiRingCat.Hom.hom f = SemiRingCat.Hom.hom g → f = g | true |
CategoryTheory.Limits.ker._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] {f g : CategoryTheory.Arrow C} (u : f ⟶ g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f.hom) u.left)
g.hom =
0 | false |
Array.mem_mapFinIdx | Init.Data.Array.MapIdx | ∀ {β : Type u_1} {α : Type u_2} {b : β} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β},
b ∈ xs.mapFinIdx f ↔ ∃ i, ∃ (h : i < xs.size), f i xs[i] h = b | true |
SignType.castHom._proof_3 | Mathlib.Data.Sign.Basic | ∀ {α : Type u_1} [inst : MulZeroOneClass α] [inst_1 : HasDistribNeg α], ↑1 = ↑1 | false |
HomotopyCategory.instIsCompatibleWithShiftHomologicalComplexIntUpHomotopic | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C],
(homotopic C (ComplexShape.up ℤ)).IsCompatibleWithShift ℤ | true |
CoheytingAlgebra.noConfusionType | Mathlib.Order.Heyting.Basic | Sort u → {α : Type u_4} → CoheytingAlgebra α → {α' : Type u_4} → CoheytingAlgebra α' → Sort u | false |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.2205948307._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit | false |
Equiv.subtypePiEquivPi._proof_2 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : α → Sort u_2} {p : (a : α) → β a → Prop},
Function.RightInverse (fun f => ⟨fun a => ↑(f a), ⋯⟩) fun f a => ⟨↑f a, ⋯⟩ | false |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq._sparseCasesOn_4 | Lean.Meta.Sym.AlphaShareCommon | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Linter.Util.0.Lean.Linter.collectMacroExpansions?.go.match_4 | Lean.Linter.Util | (motive : List (List Lean.Elab.MacroExpansionInfo) → Sort u_1) →
(results : List (List Lean.Elab.MacroExpansionInfo)) →
((results : List Lean.Elab.MacroExpansionInfo) →
(tail : List (List Lean.Elab.MacroExpansionInfo)) → motive (results :: tail)) →
((x : List (List Lean.Elab.MacroExpansionInfo)) → motive x) → motive results | false |
AddSubsemigroup.equivOp_apply_coe | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (H : AddSubsemigroup M) (a : ↥H), ↑(H.equivOp a) = AddOpposite.op ↑a | true |
MeasureTheory.Measure.measure_univ_pos._simp_1 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (0 < μ Set.univ) = (μ ≠ 0) | false |
AddCircle.measurableEquivIoc.congr_simp | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | ∀ (T : ℝ) [hT : Fact (0 < T)] (a : ℝ), AddCircle.measurableEquivIoc T a = AddCircle.measurableEquivIoc T a | true |
MonotoneOn.map_sSup_of_continuousWithinAt | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : CompleteLinearOrder β] [inst_4 : TopologicalSpace β] [OrderClosedTopology β] {f : α → β} {s : Set α},
ContinuousWithinAt f s (sSup s) → MonotoneOn f s → f ⊥ = ⊥ → f (sSup s) = sSup (f '' s) | true |
_private.LeanSearchClient.LoogleSyntax.0.LeanSearchClient.getLoogleQueryJson.match_4 | LeanSearchClient.LoogleSyntax | (motive : Except String (Array Lean.Json) → Sort u_1) →
(x : Except String (Array Lean.Json)) →
((arr : Array Lean.Json) → motive (Except.ok arr)) → ((e : String) → motive (Except.error e)) → motive x | false |
CoalgHomClass | Mathlib.RingTheory.Coalgebra.Hom | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] →
[inst_3 : AddCommMonoid B] →
[inst_4 : Module R B] → [CoalgebraStruct R A] → [CoalgebraStruct R B] → [FunLike F A B] → Prop | true |
_private.Lean.Environment.0.Lean.Environment.asyncConstsMap._default | Lean.Environment | Lean.VisibilityMap✝ Lean.AsyncConsts✝ | false |
_private.Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite.0.SimpleGraph.completeEquipartiteGraph_succ_isContained_iff._simp_1_15 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {a : Prop}, (a → a) = True | false |
Polynomial.IsMonicOfDegree.of_mul_left | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Semiring R] {p q : Polynomial R} {m n : ℕ},
p.IsMonicOfDegree m → (p * q).IsMonicOfDegree (m + n) → q.IsMonicOfDegree n | true |
NonUnitalSubalgebra.toNonUnitalSemiring | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] → [inst_2 : Module R A] → (S : NonUnitalSubalgebra R A) → NonUnitalSemiring ↥S | true |
OrderHom.uliftLeftMap | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → (α →o β) → ULift.{u_8, u_2} α →o β | true |
Std.not_lt_of_ge | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] {a b : α}, a ≤ b → ¬b < a | true |
CategoryTheory.MonoidalCategory.associator_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} {𝒞 : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.MonoidalCategory C] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C}
(f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₁ (CategoryTheory.MonoidalCategoryStruct.tensorObj Y₂ Y₃) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂) f₃)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Y₁ Y₂ Y₃).hom h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X₁ X₂ X₃).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ (CategoryTheory.MonoidalCategoryStruct.tensorHom f₂ f₃)) h) | true |
ContinuousLinearMap.uniformContinuous | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {E₁ : Type u_9}
{E₂ : Type u_10} [inst_2 : UniformSpace E₁] [inst_3 : UniformSpace E₂] [inst_4 : AddCommGroup E₁]
[inst_5 : AddCommGroup E₂] [inst_6 : Module R₁ E₁] [inst_7 : Module R₂ E₂] [IsUniformAddGroup E₁]
[IsUniformAddGroup E₂] (f : E₁ →SL[σ₁₂] E₂), UniformContinuous ⇑f | true |
_private.Init.Data.Array.Lemmas.0.Array.append_eq_singleton_iff._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a b : List α} {x : α}, (a ++ b = [x]) = (a = [] ∧ b = [x] ∨ a = [x] ∧ b = []) | false |
CategoryTheory.Limits.LimitBicone.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} {inst : CategoryTheory.Category.{uC', uC} C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {F : J → C} {bicone : CategoryTheory.Limits.Bicone F}
{isBilimit : bicone.IsBilimit} {bicone_1 : CategoryTheory.Limits.Bicone F} {isBilimit_1 : bicone_1.IsBilimit},
{ bicone := bicone, isBilimit := isBilimit } = { bicone := bicone_1, isBilimit := isBilimit_1 } →
bicone = bicone_1 ∧ isBilimit ≍ isBilimit_1 | true |
DFinsupp.small | Mathlib.Data.DFinsupp.Small | ∀ {ι : Type u} {π : ι → Type v} [inst : (i : ι) → Zero (π i)] [Small.{w, u} ι] [∀ (i : ι), Small.{w, v} (π i)],
Small.{w, max v u} (DFinsupp π) | true |
SSet.N.cast | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | {X : SSet} → (s : X.N) → {d : ℕ} → s.dim = d → X.N | true |
Std.Internal.List.isEmpty_filter_containsKey_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)},
l₁.isEmpty = true → (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁).isEmpty = true | true |
CategoryTheory.PreZeroHypercover.sectionsSaturateEquiv_apply_coe | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.Functor Cᵒᵖ (Type u_3)) (s : (E.saturate.multicospanIndex F).sections)
(i : E.saturate.multicospanShape.L), ↑((E.sectionsSaturateEquiv F) s) i = s.val i | true |
NonUnitalNonAssocCommRing.mul_comm | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonUnitalNonAssocCommRing α] (a b : α), a * b = b * a | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.sc._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i : ℕ), ¬i + 1 + 1 = i + 2 → False | false |
CategoryTheory.PreGaloisCategory.endEquivAutGalois | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
(F : CategoryTheory.Functor C FintypeCat) →
[CategoryTheory.PreGaloisCategory.FiberFunctor F] →
CategoryTheory.End F ≃ CategoryTheory.PreGaloisCategory.AutGalois F | true |
SSet.Truncated.StrictSegal.spineToSimplex_interval | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)} (sx : X.StrictSegal) (m : ℕ) (h : m ≤ n + 1) (f : X.Path m) (j l : ℕ)
(hjl : j + l ≤ m),
X.map (SimplexCategory.Truncated.Hom.tr (SimplexCategory.subinterval j l hjl) ⋯ h).op (sx.spineToSimplex m h f) =
sx.spineToSimplex l ⋯ (f.interval j l hjl) | true |
NonUnitalAlgHom.mk.inj | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} {inst : Monoid R} {inst_1 : Monoid S} {φ : R →* S} {A : Type v} {B : Type w}
{inst_2 : NonUnitalNonAssocSemiring A} {inst_3 : DistribMulAction R A} {inst_4 : NonUnitalNonAssocSemiring B}
{inst_5 : DistribMulAction S B} {toDistribMulActionHom : A →ₑ+[φ] B}
{map_mul' :
∀ (x y : A), toDistribMulActionHom.toFun (x * y) = toDistribMulActionHom.toFun x * toDistribMulActionHom.toFun y}
{toDistribMulActionHom_1 : A →ₑ+[φ] B}
{map_mul'_1 :
∀ (x y : A),
toDistribMulActionHom_1.toFun (x * y) = toDistribMulActionHom_1.toFun x * toDistribMulActionHom_1.toFun y},
{ toDistribMulActionHom := toDistribMulActionHom, map_mul' := map_mul' } =
{ toDistribMulActionHom := toDistribMulActionHom_1, map_mul' := map_mul'_1 } →
toDistribMulActionHom = toDistribMulActionHom_1 | true |
LowerSemicontinuousWithinAt | Mathlib.Topology.Semicontinuity.Defs | {α : Type u_1} → {β : Type u_2} → [TopologicalSpace α] → [Preorder β] → (α → β) → Set α → α → Prop | true |
List.mem_foldr_permutationsAux2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {t : α} {ts : List α} {r L : List (List α)} {l' : List α},
l' ∈ List.foldr (fun y r => (List.permutationsAux2 t ts r y id).2) r L ↔
l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts | true |
Lean.Parser.ParserCacheEntry.mk._flat_ctor | Lean.Parser.Types | Lean.Syntax → ℕ → String.Pos.Raw → Option Lean.Parser.Error → Lean.Parser.ParserCacheEntry | false |
Matrix.isRepresentation._proof_4 | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | ∀ {ι : Type u_3} [inst : Fintype ι] {M : Type u_1} [inst_1 : AddCommGroup M] (R : Type u_2) [inst_2 : CommRing R]
[inst_3 : Module R M] (b : ι → M) [inst_4 : DecidableEq ι], ∃ f, Matrix.Represents b 0 f | false |
StandardEtalePair.Ring | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} → [inst : CommRing R] → StandardEtalePair R → Type u_1 | true |
Std.DHashMap.Raw.instMembershipOfBEqOfHashable | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Membership α (Std.DHashMap.Raw α β) | true |
_private.Lean.Util.CollectLevelParams.0.Lean.CollectLevelParams.State.getUnusedLevelParam.loop | Lean.Util.CollectLevelParams | Lean.CollectLevelParams.State → Lean.Name → ℕ → Lean.Level | true |
_private.Init.Data.Array.Range.0.Array.range'_concat._simp_1_1 | Init.Data.Array.Range | ∀ {s m n step : ℕ}, Array.range' s (m + n) step = Array.range' s m step ++ Array.range' (s + step * m) n step | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.