name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.g'_eq | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {cc : CategoryTheory.Limits.CokernelCofork S.f}
(hcc : CategoryTheory.Limits.IsColimit cc),
hcc.desc (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯) =
CategoryTheory.CategoryStruct.comp (S.isoOpcyclesOfIsColimit hcc).hom S.fromOpcycles | true |
Filter.EventuallyEq.star | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {R : Type u_2} [inst : Star R] {f g : α → R} {l : Filter α}, f =ᶠ[l] g → star f =ᶠ[l] star g | true |
Nat.primeCounting.eq_1 | Mathlib.NumberTheory.PrimeCounting | ∀ (n : ℕ), n.primeCounting = (n + 1).primeCounting' | true |
exists_compact_superset | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [WeaklyLocallyCompactSpace X] {K : Set X},
IsCompact K → ∃ K', IsCompact K' ∧ K ⊆ interior K' | true |
MulAction.instDecidablePredMemSubmonoidStabilizerSubmonoidOfDecidableEq | Mathlib.GroupTheory.GroupAction.Defs | {M : Type u_1} →
{α : Type u_3} →
[inst : Monoid M] →
[inst_1 : MulAction M α] →
[DecidableEq α] → (a : α) → DecidablePred fun x => x ∈ MulAction.stabilizerSubmonoid M a | true |
Lean.Elab.Term.Do.Var | Lean.Elab.Do.Legacy | Type | true |
AffineEquiv.list_sbtw_map_iff | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {V' : Type u_3} {P : Type u_4} {P' : Type u_5} [inst : Ring R] [inst_1 : PartialOrder R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup V']
[inst_6 : Module R V'] [inst_7 : AddTorsor V' P'] {l : List P} (f : P ≃ᵃ[R] P'),
List.Sbtw R (List.map (⇑f) l) ↔ List.Sbtw R l | true |
_private.Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization.0.HomogeneousLocalization.Away.isLocalization_mul._simp_1_5 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {x y : M × ↥S},
(Localization.r S) x y = ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1) | false |
DirectSum | Mathlib.Algebra.DirectSum.Basic | (ι : Type v) → (β : ι → Type w) → [(i : ι) → AddCommMonoid (β i)] → Type (max w v) | true |
AddSubgroup.Normal.pathComponentZero | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
(AddSubgroup.pathComponentZero G).Normal | true |
CompleteLatticeHom.toBoundedLatticeHom._proof_4 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : CompleteLatticeHom α β)
(a b : α),
{ toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | false |
BitVec.ushiftRight_eq' | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ : ℕ} (x : BitVec w₁) (y : BitVec w₂), x >>> y = x >>> y.toNat | true |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_14 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (tail : List α),
List.findIdxNth p tail (List.countPBefore p tail (List.findIdxNth p tail 0)) + 1 ≤ tail.length →
List.findIdxNth p tail (List.countPBefore p tail (List.findIdxNth p tail 0)) < tail.length | false |
LinearEquiv.rTensor_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N ≃ₗ[R] P) (m : M) (p : P), (LinearEquiv.rTensor M f).symm (p ⊗ₜ[R] m) = f.symm p ⊗ₜ[R] m | true |
DeltaGeneratedSpace.instLocPathConnectedSpace | Mathlib.Topology.Compactness.DeltaGeneratedSpace | ∀ {X : Type u_1} [tX : TopologicalSpace X] [DeltaGeneratedSpace X], LocPathConnectedSpace X | true |
_private.Mathlib.CategoryTheory.MorphismProperty.Basic.0.CategoryTheory.MorphismProperty.toSet_iSup._simp_1_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
(f : CategoryTheory.Arrow C), (f ∈ P.toSet) = P f.hom | false |
Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM | Lean.PrettyPrinter.Delaborator.Basic | MonadReaderOf Lean.SubExpr Lean.PrettyPrinter.Delaborator.DelabM | true |
Submonoid.disjoint_def' | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] {p₁ p₂ : Submonoid M},
Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1 | true |
Turing.ToPartrec.stepNormal.eq_def | Mathlib.Computability.TuringMachine.Config | ∀ (x : Turing.ToPartrec.Code),
Turing.ToPartrec.stepNormal x =
match (motive := Turing.ToPartrec.Code → Turing.ToPartrec.Cont → List ℕ → Turing.ToPartrec.Cfg) x with
| Turing.ToPartrec.Code.zero' => fun k v => Turing.ToPartrec.Cfg.ret k (0 :: v)
| Turing.ToPartrec.Code.succ => fun k v => Turing.ToPartrec.Cfg.ret k [v.headI.succ]
| Turing.ToPartrec.Code.tail => fun k v => Turing.ToPartrec.Cfg.ret k v.tail
| f.cons fs => fun k v => Turing.ToPartrec.stepNormal f (Turing.ToPartrec.Cont.cons₁ fs v k) v
| f.comp g => fun k v => Turing.ToPartrec.stepNormal g (Turing.ToPartrec.Cont.comp f k) v
| f.case g => fun k v =>
Nat.rec (Turing.ToPartrec.stepNormal f k v.tail) (fun y x => Turing.ToPartrec.stepNormal g k (y :: v.tail))
v.headI
| f.fix => fun k v => Turing.ToPartrec.stepNormal f (Turing.ToPartrec.Cont.fix f k) v | true |
Ordinal.isInitialIso_symm_apply_coe | Mathlib.SetTheory.Cardinal.Aleph | ∀ (x : Cardinal.{u_1}), ↑((RelIso.symm Ordinal.isInitialIso) x) = x.ord | true |
ClopenUpperSet.instSetLike._proof_1 | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] (s t : ClopenUpperSet α),
(fun s => s.carrier) s = (fun s => s.carrier) t → s = t | false |
UInt16.toBitVec_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt16), n.toUInt8.toBitVec = BitVec.setWidth 8 n.toBitVec | true |
Lean.instReprExpr.repr._unsafe_rec | Lean.Expr | Lean.Expr → ℕ → Std.Format | false |
LinearMap.isPairSelfAdjointSubmodule._proof_3 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup M₂] [inst_4 : Module R M₂] (B F : M →ₗ[R] M →ₗ[R] M₂) (c : R),
∀ x ∈ {f | B.IsPairSelfAdjoint F ⇑f}, B.IsAdjointPair F (c • ⇑x) (c • ⇑x) | false |
Matrix.SpecialLinearGroup.instCoeFun | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
{R : Type v} → [inst_2 : CommRing R] → CoeFun (Matrix.SpecialLinearGroup n R) fun x => n → n → R | true |
SaturatedAddSubmonoid.instCompleteLattice._proof_2 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M] (a b : SaturatedAddSubmonoid M), b ≤ SemilatticeSup.sup a b | false |
birkhoffAverage_neg | Mathlib.Dynamics.BirkhoffSum.Average | ∀ {R : Type u_1} {α : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] {f : α → α} {g : α → M}, birkhoffAverage R f (-g) = -birkhoffAverage R f g | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Real.abs_sin_eq_one_iff._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {x : ℝ} (n : ℤ), Real.pi / 2 + ↑n * (2 * Real.pi) = x → Real.pi / 2 + IntCast.intCast (2 * n) * Real.pi = x | false |
WithZero.lift'_zero | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulZeroOneClass β] (f : α →* β),
(WithZero.lift' f) 0 = 0 | true |
_private.Init.Data.Vector.Lemmas.0.Array.mapM.map.eq_def | Init.Data.Vector.Lemmas | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (f : α → m β) (as : Array α) (i : ℕ) (bs : Array β),
Array.mapM.map✝ f as i bs =
if hlt : i < as.size then do
let __do_lift ← f as[i]
Array.mapM.map✝¹ f as (i + 1) (bs.push __do_lift)
else pure bs | true |
MeasureTheory.lpNorm_const_smul | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} [inst : NormedAddCommGroup E] {𝕜 : Type u_3}
[inst_1 : NormedField 𝕜] [inst_2 : Module 𝕜 E] [NormSMulClass 𝕜 E] (c : 𝕜) (f : α → E) (μ : MeasureTheory.Measure α),
MeasureTheory.lpNorm (c • f) p μ = ↑‖c‖₊ * MeasureTheory.lpNorm f p μ | true |
CategoryTheory.Functor.Monoidal.whiskerRight_δ_μ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C) (T : D) {Z : D}
(h :
CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)) T ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.OplaxMonoidal.δ F X Y) T)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.LaxMonoidal.μ F X Y) T) h) =
h | true |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.328880924._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit | false |
IsLocalization.ringEquivOfRingEquiv_symm | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {T : Submonoid P}
{Q : Type u_4} [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T Q] {j : R ≃+* P}
(H : Submonoid.map j M = T),
(IsLocalization.ringEquivOfRingEquiv S Q j H).symm = IsLocalization.ringEquivOfRingEquiv Q S j.symm ⋯ | true |
compl_strictAnti | Mathlib.Order.Hom.Set | ∀ (α : Type u_1) [inst : BooleanAlgebra α], StrictAnti compl | true |
CategoryTheory.Sieve.BindStruct | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(S : CategoryTheory.Presieve X) →
(⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y) → {Z : C} → (Z ⟶ X) → Type (max u₁ v₁) | true |
Nat.toArray_ric_eq_toArray_rcc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toArray = (0...=n).toArray | true |
Int.add_assoc | Init.Data.Int.Lemmas | ∀ (a b c : ℤ), a + b + c = a + (b + c) | true |
IdealFilter.gabrielComposition | Mathlib.RingTheory.IdealFilter.Basic | {A : Type u_1} → [inst : Ring A] → IdealFilter A → IdealFilter A → IdealFilter A | true |
CategoryTheory.OplaxFunctor.PseudoCore.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F : CategoryTheory.OplaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C]
(mapIdIso : (a : B) → F.map (CategoryTheory.CategoryStruct.id a) ≅ CategoryTheory.CategoryStruct.id (F.obj a))
(mapCompIso :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
F.map (CategoryTheory.CategoryStruct.comp f g) ≅ CategoryTheory.CategoryStruct.comp (F.map f) (F.map g))
(mapIdIso_hom :
autoParam (∀ {a : B}, (mapIdIso a).hom = F.mapId a) CategoryTheory.OplaxFunctor.PseudoCore.mapIdIso_hom._autoParam)
(mapCompIso_hom :
autoParam (∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), (mapCompIso f g).hom = F.mapComp f g)
CategoryTheory.OplaxFunctor.PseudoCore.mapCompIso_hom._autoParam),
sizeOf
{ mapIdIso := mapIdIso, mapCompIso := mapCompIso, mapIdIso_hom := mapIdIso_hom,
mapCompIso_hom := mapCompIso_hom } =
1 | true |
YoungDiagram.transpose_transpose | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ : YoungDiagram), μ.transpose.transpose = μ | true |
continuousAt_extChartAt_symm | 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] (x : M),
ContinuousAt (↑(extChartAt I x).symm) (↑(extChartAt I x) x) | true |
NonUnitalRingHom.fst_comp_prod | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} {T : Type u_5} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring T] (f : R →ₙ+* S) (g : R →ₙ+* T),
(NonUnitalRingHom.fst S T).comp (f.prod g) = f | true |
WeierstrassCurve.Jacobian.map_add | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} {K : Type v} [inst : Field F] [inst_1 : Field K] {W : WeierstrassCurve.Jacobian F} (f : F →+* K)
{P Q : Fin 3 → F},
W.Nonsingular P → W.Nonsingular Q → (WeierstrassCurve.map W f).toJacobian.add (⇑f ∘ P) (⇑f ∘ Q) = ⇑f ∘ W.add P Q | true |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ico_filter_dvd_eq._simp_1_4 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [inst_2 : FloorRing α] {z : ℤ} {a : α}, (⌈a⌉ ≤ z) = (a ≤ ↑z) | false |
Finset.prod_extend_by_one | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : CommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → M),
(∏ i ∈ s, if i ∈ s then f i else 1) = ∏ i ∈ s, f i | true |
IsCompactOperator.antilipschitz_of_not_hasEigenvalue | Mathlib.Analysis.Normed.Operator.FredholmAlternative | ∀ {𝕜 : Type u_1} {X : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] {T : X →L[𝕜] X} {μ : 𝕜},
IsCompactOperator ⇑T → μ ≠ 0 → ¬Module.End.HasEigenvalue (↑T) μ → ∃ K, AntilipschitzWith K ⇑(T - μ • 1) | true |
Std.Do.PredTrans.pushOption.match_1 | Std.Do.PredTrans | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x | false |
StrongDual.extendRCLikeₗᵢ_symm_apply | Mathlib.Analysis.Normed.Module.RCLike.Extend | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F]
[inst_3 : NormedSpace ℝ F] [inst_4 : IsScalarTower ℝ 𝕜 F] (f : StrongDual 𝕜 F),
StrongDual.extendRCLikeₗᵢ.symm f = ContinuousLinearMap.comp RCLike.reCLM (ContinuousLinearMap.restrictScalars ℝ f) | true |
CategoryTheory.typesGrothendieckTopology._proof_2 | Mathlib.CategoryTheory.Sites.Types | ∀ (x : Type u_1),
∀ x_1 ∈ {S | ∀ (x_2 : x), S.arrows fun x => x_2},
∀ (x_2 : CategoryTheory.Sieve x),
(∀ ⦃Y : Type u_1⦄ ⦃f : Y ⟶ x⦄,
x_1.arrows f → CategoryTheory.Sieve.pullback f x_2 ∈ {S | ∀ (x : Y), S.arrows fun x_3 => x}) →
∀ (x_3 : x), (CategoryTheory.Sieve.pullback (fun x => x_3) x_2).arrows fun x => PUnit.unit | false |
Isometry.of_dist_eq | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
(∀ (x y : α), dist (f x) (f y) = dist x y) → Isometry f | true |
WeierstrassCurve.Jacobian.toAffine | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | {R : Type r} → WeierstrassCurve.Jacobian R → WeierstrassCurve.Affine R | true |
Metric.mem_ball_self | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, 0 < ε → x ∈ Metric.ball x ε | true |
CategoryTheory.Grothendieck.final_pre | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D CategoryTheory.Cat) (G : CategoryTheory.Functor C D) [hG : G.Final],
(CategoryTheory.Grothendieck.pre F G).Final | true |
CategoryTheory.Limits.CategoricalPullback.toCatCommSqOver_obj_snd_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X]
(J : CategoryTheory.Functor X (CategoryTheory.Limits.CategoricalPullback F G)) (X_1 : X),
((CategoryTheory.Limits.CategoricalPullback.toCatCommSqOver F G X).obj J).snd.obj X_1 = (J.obj X_1).snd | true |
_private.Mathlib.Algebra.Homology.SpectralSequence.ComplexShape.0.ComplexShape.spectralSequenceFin._proof_1 | Mathlib.Algebra.Homology.SpectralSequence.ComplexShape | ∀ (l : ℕ) (u : ℤ × ℤ) {i j j' : ℤ × Fin l},
i.1 + u.1 = j.1 ∧ ↑↑i.2 + u.2 = ↑↑j.2 → i.1 + u.1 = j'.1 ∧ ↑↑i.2 + u.2 = ↑↑j'.2 → j.1 = j'.1 | false |
Lean.Parser.Term.let_tmp._regBuiltin.Lean.Parser.Term.let_tmp.formatter_9 | Lean.Parser.Term | IO Unit | false |
_private.Init.Data.Option.Basic.0.Option.instLawfulBEq.match_1 | Init.Data.Option.Basic | ∀ (α : Type u_1) [inst : BEq α] (motive : (x y : Option α) → {h : (x == y) = true} → Prop) (x y : Option α)
{h : (x == y) = true},
(∀ (x y : α) (h : (some x == some y) = true), motive (some x) (some y)) →
(∀ (h : (none == none) = true), motive none none) → motive x y | false |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.nonempty_type_iff_nonempty.match_1_3 | Mathlib.SetTheory.ZFC.PSet | ∀ {x : PSet.{u_1}} (motive : x.Nonempty → Prop) (x_1 : x.Nonempty),
(∀ (w : PSet.{u_1}) (j : x.Type) (h : w.Equiv (x.Func j)), motive ⋯) → motive x_1 | false |
_private.Lean.Server.Completion.CompletionUtils.0.Lean.Server.Completion.minimizeGlobalIdentifierInContext.shortenInOpenNamespace | Lean.Server.Completion.CompletionUtils | Lean.Name → Lean.Name → Lean.Name | true |
ContDiffAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {n : WithTop ℕ∞},
ContDiffAt ℝ n f x → f x ≠ 0 → ContDiffAt ℝ n (fun x => Real.log (f x)) x | true |
LLVM.Attribute._sizeOf_inst | Lean.Compiler.IR.LLVMBindings | (ctx : LLVM.Context) → SizeOf (LLVM.Attribute ctx) | false |
Representation.equivOfIso._proof_4 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{u_1, u_2, u_3} k G} (i : A ≅ B)
(m : k) (x : ↑A), (Rep.Hom.hom i.hom).toFun (m • x) = (RingHom.id k) m • (Rep.Hom.hom i.hom).toFun x | false |
MeasureTheory.Lp.constₗ_apply | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : NormedAddCommGroup E] [inst_1 : MeasureTheory.IsFiniteMeasure μ] (𝕜 : Type u_3) [inst_2 : NormedRing 𝕜]
[inst_3 : Module 𝕜 E] [inst_4 : IsBoundedSMul 𝕜 E] (a : E),
(MeasureTheory.Lp.constₗ p μ 𝕜) a = (MeasureTheory.Lp.const p μ) a | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.psum_eq_mul_esymm_sub_sum._proof_1_5 | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (k : ℕ), 0 < k → (0, k).1 + (0, k).2 = k ∧ (0, k).1 < k ∧ ¬0 < (0, k).1 | false |
Set.biInter_insert | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (a : α) (s : Set α) (t : α → Set β), ⋂ x ∈ insert a s, t x = t a ∩ ⋂ x ∈ s, t x | true |
MeasureTheory.Content.is_add_left_invariant_innerContent | Mathlib.MeasureTheory.Measure.Content | ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : AddGroup G]
[inst_2 : SeparatelyContinuousAdd G],
(∀ (g : G) {K : TopologicalSpace.Compacts G}, μ (TopologicalSpace.Compacts.map (fun x => g + x) ⋯ K) = μ K) →
∀ (g : G) (U : TopologicalSpace.Opens G),
μ.innerContent ((TopologicalSpace.Opens.comap ↑(Homeomorph.addLeft g)) U) = μ.innerContent U | true |
Lean.Lsp.instFromJsonWorkDoneProgressParams.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.WorkDoneProgressParams | true |
Lean.MetavarDecl.lctx | Lean.MetavarContext | Lean.MetavarDecl → Lean.LocalContext | true |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_5 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α), [] = xs → [x].isEmpty = true → xs ≠ [] | false |
homeomorphSphereProd._proof_7 | Mathlib.Analysis.Normed.Module.Ball.RadialEquiv | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] (r : ℝ), 0 < r → ∀ (x : ↑{0}ᶜ), 0 < ‖↑x‖ → ‖↑x‖ / r ∈ Set.Ioi 0 | false |
instLinearOrderedAddCommMonoidWithTopAdditiveOrderDual._proof_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] (a : Additive αᵒᵈ), ⊤ + a = ⊤ | false |
DirichletCharacter.Odd.eval_neg | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {S : Type u_2} [inst : CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) (x : ZMod m), ψ.Odd → ψ (-x) = -ψ x | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.foldM.match_1.eq_1 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (motive : Option (α × Batteries.BinomialHeap.Imp.Heap α) → Sort u_2) (h_1 : none = none → motive none)
(h_2 : (hd : α) → (tl : Batteries.BinomialHeap.Imp.Heap α) → none = some (hd, tl) → motive (some (hd, tl))),
(match eq : none with
| none => h_1 eq
| some (hd, tl) => h_2 hd tl eq) =
h_1 ⋯ | true |
Submodule.mk_eq_bot | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(carrier : AddSubmonoid M) (smul_mem' : ∀ (c : R) {x : M}, x ∈ carrier.carrier → c • x ∈ carrier.carrier),
{ toAddSubmonoid := carrier, smul_mem' := smul_mem' } = ⊥ ↔ carrier = ⊥ | true |
List.mem_dropLast_of_mem_of_ne_getLast? | Mathlib.Data.List.Basic | ∀ {α : Type u} {l : List α} {a : α}, a ∈ l → some a ≠ l.getLast? → a ∈ l.dropLast | true |
Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.ConfigOptions.966831148._hygCtx._hyg.4 | Lean.Compiler.LCNF.ConfigOptions | IO (Lean.Option ℕ) | false |
Lean.Meta.Grind.propagateBEqUp._regBuiltin.Lean.Meta.Grind.propagateBEqUp.declare_1._@.Lean.Meta.Tactic.Grind.Propagate.4192136612._hygCtx._hyg.8 | Lean.Meta.Tactic.Grind.Propagate | IO Unit | false |
Turing.TM2to1.tr_respects | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [inst : DecidableEq K]
(M : Λ → Turing.TM2.Stmt Γ Λ σ),
StateTransition.Respects (Turing.TM2.step M) (Turing.TM1.step (Turing.TM2to1.tr M)) Turing.TM2to1.TrCfg | true |
Sat.Valuation.satisfies_fmla.recOn | Mathlib.Tactic.Sat.FromLRAT | {v : Sat.Valuation} →
{f : Sat.Fmla} →
{motive : v.satisfies_fmla f → Sort u} →
(t : v.satisfies_fmla f) → ((prop : ∀ c ∈ f, v.satisfies c) → motive ⋯) → motive t | false |
CategoryTheory.Limits.instHasKernelπ | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) (i : J)
[inst_2 : CategoryTheory.Limits.HasBiproduct f]
[CategoryTheory.Limits.HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)],
CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.biproduct.π f i) | true |
Lean.addDocString' | Lean.DocString.Add | Lean.Name → Lean.Syntax → Option (Lean.TSyntax `Lean.Parser.Command.docComment) → Lean.Elab.TermElabM Unit | true |
HahnSeries.SummableFamily.instSMul_1 | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{Γ' : Type u_2} →
{R : Type u_3} →
{V : Type u_4} →
{β : Type u_6} →
[inst : PartialOrder Γ] →
[inst_1 : PartialOrder Γ'] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid R] →
[SMulWithZero R V] →
[inst_5 : VAdd Γ Γ'] →
[IsOrderedCancelVAdd Γ Γ'] → SMul (HahnSeries Γ R) (HahnSeries.SummableFamily Γ' V β) | true |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.mkIndCtorElim | Lean.Meta.Constructions.CtorElim | Lean.Name → Lean.MetaM Unit | true |
IsAlgebraic.mul | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [NoZeroDivisors R]
{a b : S}, IsAlgebraic R a → IsAlgebraic R b → IsAlgebraic R (a * b) | true |
Positive.isOrderedCancelMonoid | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_2} [inst : CommSemiring R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R],
IsOrderedCancelMonoid { x // 0 < x } | true |
Polynomial.monic_finprod_X_sub_C | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] {α : Type u_1} (b : α → R), (∏ᶠ (k : α), (Polynomial.X - Polynomial.C (b k))).Monic | true |
Std.Sat.AIG.of_isConstant | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {assign : α → Bool} {ref : aig.Ref}
{b : Bool}, aig.isConstant ref b = true → ⟦assign, { aig := aig, ref := ref }⟧ = b | true |
UniformSpace.Core.mk'._proof_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} (U : Filter (α × α)), (∀ r ∈ U, ∀ (x : α), (x, x) ∈ r) → ∀ _r ∈ U, SetRel.id ⊆ _r | false |
Batteries.PairingHeapImp.Heap._sizeOf_inst | Batteries.Data.PairingHeap | (α : Type u) → [SizeOf α] → SizeOf (Batteries.PairingHeapImp.Heap α) | false |
CategoryTheory.Comonad.ForgetCreatesLimits'.lambda | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{T : CategoryTheory.Comonad C} →
{D : CategoryTheory.Functor J T.Coalgebra} →
(c : CategoryTheory.Limits.Cone (D.comp T.forget)) →
CategoryTheory.Limits.IsLimit c →
[CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor] → c.pt ⟶ (T.mapCone c).pt | true |
Std.Internal.Parsec.manyCore | Std.Internal.Parsec.Basic | {α ι elem idx : Type} →
[inst : DecidableEq idx] →
[inst_1 : DecidableEq elem] →
[Std.Internal.Parsec.Input ι elem idx] → Std.Internal.Parsec ι α → Array α → Std.Internal.Parsec ι (Array α) | true |
_private.Init.Data.Range.Polymorphic.SInt.0.ISize.instHasModelBitVecNumBits | Init.Data.Range.Polymorphic.SInt | HasModel✝ ISize (BitVec System.Platform.numBits) | true |
CategoryTheory.Oplax.OplaxTrans.whiskerLeft_naturality_comp_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{G H : CategoryTheory.OplaxFunctor B C} (θ : CategoryTheory.Oplax.OplaxTrans G H) {a b c : B} {a' : C}
(f : a' ⟶ G.obj a) (g : a ⟶ b) (h : b ⟶ c) {Z : a' ⟶ H.obj c}
(h_1 :
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (θ.app a) (CategoryTheory.CategoryStruct.comp (H.map g) (H.map h))) ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (θ.naturality (CategoryTheory.CategoryStruct.comp g h)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerLeft (θ.app a) (H.mapComp g h)))
h_1) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight (G.mapComp g h) (θ.app c)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f
(CategoryTheory.Bicategory.associator (G.map g) (G.map h) (θ.app c)).hom)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerLeft (G.map g) (θ.naturality h)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f
(CategoryTheory.Bicategory.associator (G.map g) (θ.app b) (H.map h)).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f
(CategoryTheory.Bicategory.whiskerRight (θ.naturality g) (H.map h)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f
(CategoryTheory.Bicategory.associator (θ.app a) (H.map g) (H.map h)).hom)
h_1))))) | true |
CategoryTheory.Sieve.le_functorPushforward_pullback | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve X),
R ≤ CategoryTheory.Sieve.functorPullback F (CategoryTheory.Sieve.functorPushforward F R) | true |
prodEquivPiFinTwo_apply | Mathlib.Logic.Equiv.Fin.Basic | ∀ (α β : Type u), ⇑(prodEquivPiFinTwo α β) = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim) | true |
CategoryTheory.Functor.mapMonCompIso | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{E : Type u₃} →
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] →
[inst_5 : CategoryTheory.MonoidalCategory E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D E} →
[inst_6 : F.LaxMonoidal] → [inst_7 : G.LaxMonoidal] → (F.comp G).mapMon ≅ F.mapMon.comp G.mapMon | true |
AffineEquiv.ofEq._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_2} {V₁ : Type u_3} {P₁ : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (S₁ S₂ : AffineSubspace k P₁), S₁ = S₂ → ↑S₁ = ↑S₂ | false |
CategoryTheory.ShortComplex.LeftHomologyData.homologyIso_hom_comp_leftHomologyIso_inv | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology] (h : S.LeftHomologyData),
CategoryTheory.CategoryStruct.comp h.homologyIso.hom h.leftHomologyIso.inv = S.leftHomologyIso.inv | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.find?_eq_some_iff._simp_1_1 | Batteries.Data.Fin.Lemmas | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.