name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Lsp.CompletionList.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CompletionList → Sort u} →
(t : Lean.Lsp.CompletionList) →
((isIncomplete : Bool) →
(items : Array Lean.Lsp.CompletionItem) → motive { isIncomplete := isIncomplete, items := items }) →
motive t |
round.eq_1 | Mathlib.Algebra.Order.Round | ∀ {α : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [inst_2 : FloorRing α] (x : α),
round x = if 2 * Int.fract x < 1 then ⌊x⌋ else ⌈x⌉ |
_private.Init.Data.SInt.Lemmas.0.Int16.toISize_ne_minValue._proof_1_2 | Init.Data.SInt.Lemmas | ∀ (a : Int16), -2 ^ 15 ≤ a.toInt → ISize.minValue.toInt ≤ -2 ^ 31 → a.toInt = ISize.minValue.toInt → False |
Nat.ToInt.of_eq | Init.Data.Int.OfNat | ∀ {a b : ℕ} {a' b' : ℤ}, ↑a = a' → ↑b = b' → a = b → a' = b' |
IsValuativeTopology.hasBasis_nhds_zero' | Mathlib.Topology.Algebra.Valued.ValuativeRel | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R],
(nhds 0).HasBasis (fun x => x ≠ 0) fun x => {x_1 | (ValuativeRel.valuation R) x_1 < x} |
MeasureTheory.«_aux_Mathlib_MeasureTheory_OuterMeasure_AE___macroRules_MeasureTheory_term∀ᵐ_∂_,__1» | Mathlib.MeasureTheory.OuterMeasure.AE | Lean.Macro |
pinGroup.instStarMulSubtypeCliffordAlgebraMemSubmonoid._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(pinGroup Q)), star (star x) = x |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.OrderRel.ne | Mathlib.Tactic.Positivity.Core | Mathlib.Meta.Positivity.OrderRel✝ |
_private.Mathlib.NumberTheory.Multiplicity.0.Nat.eight_dvd_sq_sub_one_of_odd._proof_1_1 | Mathlib.NumberTheory.Multiplicity | ∀ (m : ℕ), (2 * m + 1) ^ 2 - 1 = 4 * (m * (m + 1)) |
Std.TreeMap.Raw.getElem_insertMany_list.match_1 | Std.Data.TreeMap.Raw.Lemmas | {β : Type u_1} →
(motive : Option β → Sort u_2) →
(x : Option β) → ((v : β) → x = some v → motive (some v)) → (x = none → motive none) → motive x |
WithLp.ofLp_multisetSum | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) (V : Type u_4) [inst : AddCommGroup V] (s : Multiset (WithLp p V)),
s.sum.ofLp = (Multiset.map WithLp.ofLp s).sum |
AlgebraicGeometry.Scheme.kerFunctor._proof_4 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ (Y : AlgebraicGeometry.Scheme) {X Y_1 Z : (CategoryTheory.Over Y)ᵒᵖ} (x : X ⟶ Y_1) (x : Y_1 ⟶ Z),
AlgebraicGeometry.Scheme.Hom.ker (Opposite.unop X).hom ≤ AlgebraicGeometry.Scheme.Hom.ker (Opposite.unop Z).hom |
CategoryTheory.bifunctorComp₂₃FunctorObj_obj | Mathlib.CategoryTheory.Functor.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_6, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄))
(G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)),
(CategoryTheory.bifunctorComp₂₃FunctorObj F).obj G₂₃ = CategoryTheory.bifunctorComp₂₃ F G₂₃ |
EuclideanDomain.toNontrivial | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u} [self : EuclideanDomain R], Nontrivial R |
BoxIntegral.TaggedPrepartition.noConfusionType | Mathlib.Analysis.BoxIntegral.Partition.Tagged | Sort u →
{ι : Type u_1} →
{I : BoxIntegral.Box ι} →
BoxIntegral.TaggedPrepartition I →
{ι' : Type u_1} → {I' : BoxIntegral.Box ι'} → BoxIntegral.TaggedPrepartition I' → Sort u |
ContinuousMap.instCompactSpaceElemCoeCompacts | Mathlib.Topology.ContinuousMap.Compact | ∀ {X : Type u_4} [inst : TopologicalSpace X] (K : TopologicalSpace.Compacts X), CompactSpace ↑↑K |
FloatArray.instEmptyCollection | Init.Data.FloatArray.Basic | EmptyCollection FloatArray |
ProbabilityTheory.defaultRatCDF | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ℚ → ℝ |
Real.rpowIntegrand₀₁_eqOn_pow_div | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p x : ℝ},
p ∈ Set.Ioo 0 1 →
0 ≤ x → Set.EqOn (fun x_1 => p.rpowIntegrand₀₁ x_1 x) (fun t => t ^ (p - 1) * x / (t + x)) (Set.Ioi 0) |
_private.Mathlib.Algebra.Module.LocalizedModule.Basic.0.IsLocalizedModule.instLiftOfLE._simp_3 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] (r : R) (m : M) (s : ↥S),
r • IsLocalizedModule.mk' f m s = IsLocalizedModule.mk' f (r • m) s |
List.attach_filterMap | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : α → Option β},
(List.filterMap f l).attach =
List.filterMap
(fun x =>
match x with
| ⟨x, h⟩ => (f x).pbind fun b m => some ⟨b, ⋯⟩)
l.attach |
UniformContinuousConstVAdd.uniformContinuous_const_vadd | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} {inst : UniformSpace X} {inst_1 : VAdd M X} [self : UniformContinuousConstVAdd M X] (c : M),
UniformContinuous fun x => c +ᵥ x |
Batteries.RBNode.upperBound? | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Ordering) → Batteries.RBNode α → optParam (Option α) none → Option α |
WithTop.mul_eq_top_iff | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {a b : WithTop α},
a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0 |
CategoryTheory.Presieve.singleton.rec | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : Y ⟶ X} →
{motive : ⦃Y_1 : C⦄ → (a : Y_1 ⟶ X) → CategoryTheory.Presieve.singleton f a → Sort u} →
motive f ⋯ → ⦃Y_1 : C⦄ → {a : Y_1 ⟶ X} → (t : CategoryTheory.Presieve.singleton f a) → motive a t |
Submonoid.LocalizationMap.map | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{P : Type u_3} →
[inst_2 : CommMonoid P] →
S.LocalizationMap N →
{g : M →* P} →
{T : Submonoid P} →
(∀ (y : ↥S), g ↑y ∈ T) → {Q : Type u_4} → [inst : CommMonoid Q] → T.LocalizationMap Q → N →* Q |
Lean.Meta.Grind.Arith.Linear.Case.fvarId | Lean.Meta.Tactic.Grind.Arith.Linear.SearchM | Lean.Meta.Grind.Arith.Linear.Case → Lean.FVarId |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unsafe_rec | Std.Sat.AIG.CNF | (aig : Std.Sat.AIG ℕ) →
(upper : ℕ) →
(h : upper < aig.decls.size) →
(state : Std.Sat.AIG.toCNF.State✝ aig) → { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state out upper h } |
AlgebraicGeometry.IsAffineOpen.isoSpec_hom | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U), hU.isoSpec.hom = U.toSpecΓ |
CategoryTheory.Comma.mapLeftIso | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(R : CategoryTheory.Functor B T) →
{L₁ L₂ : CategoryTheory.Functor A T} → (L₁ ≅ L₂) → (CategoryTheory.Comma L₁ R ≌ CategoryTheory.Comma L₂ R) |
_private.Mathlib.CategoryTheory.ConnectedComponents.0.CategoryTheory.instIsConnectedComponent._proof_10 | Mathlib.CategoryTheory.ConnectedComponents | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (j₁ j₂ : J),
CategoryTheory.ConnectedComponents.objectProperty (Quotient.mk'' j₂) j₁ →
∀ (l : List J),
(∀ a ∈ l, CategoryTheory.Zigzag a j₂) → -1 * ↑(j₁ :: l).length + 1 ≤ 0 → (j₁ :: l).length - 1 < (j₁ :: l).length |
TopModuleCat.instIsRightAdjointTopCatForget₂ContinuousLinearMapIdCarrierContinuousMapCarrier | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u) [inst : Ring R] [inst_1 : TopologicalSpace R],
(CategoryTheory.forget₂ (TopModuleCat R) TopCat).IsRightAdjoint |
Complex.UnitDisc | Mathlib.Analysis.Complex.UnitDisc.Basic | Type |
CochainComplex.HomComplex.Cochain.rightShift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | IsRightCancelAdd ℤ |
Lean.Meta.Grind.TopSort.State.recOn | Lean.Meta.Tactic.Grind.EqResolution | {motive : Lean.Meta.Grind.TopSort.State → Sort u} →
(t : Lean.Meta.Grind.TopSort.State) →
((tempMark permMark : Std.HashSet Lean.Expr) →
(result : Array Lean.Expr) → motive { tempMark := tempMark, permMark := permMark, result := result }) →
motive t |
cfc_const._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
Std.Packages.LinearPreorderOfLEArgs.rec | Init.Data.Order.PackageFactories | {α : Type u} →
{motive : Std.Packages.LinearPreorderOfLEArgs α → Sort u_1} →
((toPreorderOfLEArgs : Std.Packages.PreorderOfLEArgs α) →
(ord :
let this := toPreorderOfLEArgs.le;
let this := toPreorderOfLEArgs.decidableLE;
Ord α) →
(le_total : ∀ (a b : α), a ≤ b ∨ b ≤ a) →
(isLE_compare :
let this := toPreorderOfLEArgs.le;
let this_1 := toPreorderOfLEArgs.decidableLE;
let this_2 := ord;
∀ (a b : α), (compare a b).isLE = true ↔ a ≤ b) →
(isGE_compare :
let this := toPreorderOfLEArgs.le;
let this_1 := toPreorderOfLEArgs.decidableLE;
have this_2 := le_total;
let this_3 := ord;
∀ (a b : α), (compare a b).isGE = true ↔ b ≤ a) →
motive
{ toPreorderOfLEArgs := toPreorderOfLEArgs, ord := ord, le_total := le_total,
isLE_compare := isLE_compare, isGE_compare := isGE_compare }) →
(t : Std.Packages.LinearPreorderOfLEArgs α) → motive t |
ENNReal.mul_div_cancel_right | Mathlib.Data.ENNReal.Inv | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → a * b / b = a |
Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.letDecl.parenthesizer_137 | Lean.Parser.Term | IO Unit |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.getEntryD.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a : α) (fallback : (a : α) × β a)
(x : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.getEntryD a fallback x =
match x with
| Std.DHashMap.Internal.AssocList.nil => fallback
| Std.DHashMap.Internal.AssocList.cons k v es =>
if (k == a) = true then ⟨k, v⟩ else Std.DHashMap.Internal.AssocList.getEntryD a fallback es |
Lean.Lsp.DidSaveTextDocumentParams.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.DidSaveTextDocumentParams → Sort u} →
((textDocument : Lean.Lsp.TextDocumentIdentifier) →
(text? : Option String) → motive { textDocument := textDocument, text? := text? }) →
(t : Lean.Lsp.DidSaveTextDocumentParams) → motive t |
Set.swap_mem_addAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMagma α] {s t : Set α} {a : α} {x : α × α},
x.swap ∈ s.addAntidiagonal t a ↔ x ∈ t.addAntidiagonal s a |
Polynomial.coeff_comp_degree_mul_degree | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
q.natDegree ≠ 0 → (p.comp q).coeff (p.natDegree * q.natDegree) = p.leadingCoeff * q.leadingCoeff ^ p.natDegree |
WeierstrassCurve.valuation_Δ_aux.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] (W : WeierstrassCurve K),
WeierstrassCurve.valuation_Δ_aux R W =
if h : WeierstrassCurve.IsIntegral R W then
⟨(IsDedekindDomain.HeightOneSpectrum.valuation K (IsDiscreteValuationRing.maximalIdeal R)) W.Δ, ⋯⟩
else ⟨⊥, WeierstrassCurve.valuation_Δ_aux._proof_4⟩ |
NonUnitalCommCStarAlgebra.rec | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : NonUnitalCommCStarAlgebra A → Sort u} →
([toNonUnitalNormedCommRing : NonUnitalNormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedSpace : NormedSpace ℂ A] →
[toIsScalarTower : IsScalarTower ℂ A A] →
[toSMulCommClass : SMulCommClass ℂ A A] →
[toStarModule : StarModule ℂ A] →
motive
{ toNonUnitalNormedCommRing := toNonUnitalNormedCommRing, toStarRing := toStarRing,
toCompleteSpace := toCompleteSpace, toCStarRing := toCStarRing,
toNormedSpace := toNormedSpace, toIsScalarTower := toIsScalarTower,
toSMulCommClass := toSMulCommClass, toStarModule := toStarModule }) →
(t : NonUnitalCommCStarAlgebra A) → motive t |
AlgHom.liftOfSurjective._proof_4 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f).IsTwoSided |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_right._simp_1_2 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) |
HDiv.hDiv | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HDiv α β γ] → α → β → γ |
Valuation.toMonoidWithZeroHom | Mathlib.RingTheory.Valuation.Basic | {R : Type u_3} →
{Γ₀ : Type u_4} → [inst : LinearOrderedCommMonoidWithZero Γ₀] → [inst_1 : Ring R] → Valuation R Γ₀ → R →*₀ Γ₀ |
Lean.Meta.Grind.EMatch.SearchState._sizeOf_inst | Lean.Meta.Tactic.Grind.EMatch | SizeOf Lean.Meta.Grind.EMatch.SearchState |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isNoncomputable._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.ComputeKind → Sort u} →
(t : Lean.Elab.ComputeKind) →
motive Lean.Elab.ComputeKind.noncomputable → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_85 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
MeasureTheory.Measure.addHaarMeasure.eq_1 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] (K₀ : TopologicalSpace.PositiveCompacts G),
MeasureTheory.Measure.addHaarMeasure K₀ =
((MeasureTheory.Measure.haar.addHaarContent K₀).measure ↑K₀)⁻¹ •
(MeasureTheory.Measure.haar.addHaarContent K₀).measure |
CategoryTheory.Functor.HomObj.naturality_assoc | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)} (self : F.HomObj G A) {c d : C} (f : c ⟶ d)
(a : A.obj c) {Z : D} (h : G.obj d ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (self.app d (A.map f a)) h) =
CategoryTheory.CategoryStruct.comp (self.app c a) (CategoryTheory.CategoryStruct.comp (G.map f) h) |
Lean.Meta.getElimExprInfo | Lean.Meta.Tactic.ElimInfo | Lean.Expr → optParam (Option Lean.Name) none → Lean.MetaM Lean.Meta.ElimInfo |
CategoryTheory.ShortComplex.RightHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_3 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.π c)
(CategoryTheory.ShortComplex.RightHomologyData.ofIsColimitCokernelCofork S hg c hc).g' =
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.ofZeros S hf hg).g'
(CategoryTheory.CategoryStruct.id S).τ₃ |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.disjoint_withBotCoe._simp_1_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b ≤ ⊥) |
TopologicalSpace.IrreducibleCloseds.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isIrreducible' : IsIrreducible carrier)
(isClosed' : IsClosed carrier) (carrier_1 : Set α) (isIrreducible'_1 : IsIrreducible carrier_1)
(isClosed'_1 : IsClosed carrier_1),
({ carrier := carrier, isIrreducible' := isIrreducible', isClosed' := isClosed' } =
{ carrier := carrier_1, isIrreducible' := isIrreducible'_1, isClosed' := isClosed'_1 }) =
(carrier = carrier_1) |
TopologicalSpace.IsTopologicalBasis.nhds_hasBasis | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {b : Set (Set α)},
TopologicalSpace.IsTopologicalBasis b → ∀ {a : α}, (nhds a).HasBasis (fun t => t ∈ b ∧ a ∈ t) fun t => t |
Int.divisorsAntidiag_neg_natCast._proof_1 | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ),
Disjoint
(Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))))
n.divisorsAntidiagonal)
(Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding)
n.divisorsAntidiagonal) |
AddMonoidHom.compHom'_apply_apply | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type uM} {N : Type uN} {P : Type uP} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] [inst_2 : AddCommMonoid P]
(f : M →+ N) (y : N →+ P) (x : M), (f.compHom' y) x = y (f x) |
Lean.MetavarContext.incDepth | Lean.MetavarContext | Lean.MetavarContext → optParam Bool false → Lean.MetavarContext |
Matrix.circulant_col_zero_eq | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} {n : Type u_3} [inst : SubtractionMonoid n] (v : n → α) (i : n), Matrix.circulant v i 0 = v i |
CategoryTheory.toSkeleton | Mathlib.CategoryTheory.Skeletal | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → C → CategoryTheory.Skeleton C |
Homotopy.mkInductiveAux₂._proof_4 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero + CategoryTheory.CategoryStruct.comp one (Q.d 2 1))
(succ :
(n : ℕ) →
(p :
(f : P.X n ⟶ Q.X (n + 1)) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×'
e.f (n + 1) =
CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f +
CategoryTheory.CategoryStruct.comp f' (Q.d (n + 2) (n + 1))) →
(f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×'
e.f (n + 2) =
CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst +
CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 3) (n + 2)))
(n : ℕ),
e.f (n + 1) =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.dFrom P (n + 1))
(CategoryTheory.CategoryStruct.comp (HomologicalComplex.xNextIso P ⋯).hom
(Homotopy.mkInductiveAux₁ e zero one comm_one succ n).fst) +
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (Homotopy.mkInductiveAux₁ e zero one comm_one succ n).snd.fst
(HomologicalComplex.xPrevIso Q ⋯).inv)
(HomologicalComplex.dTo Q (n + 1)) |
Ideal.radical_le_jacobson | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical ≤ I.jacobson |
Lean.DataValue.ofString.injEq | Lean.Data.KVMap | ∀ (v v_1 : String), (Lean.DataValue.ofString v = Lean.DataValue.ofString v_1) = (v = v_1) |
Lean.Elab.Term.PostponeBehavior.partial.sizeOf_spec | Lean.Elab.SyntheticMVars | sizeOf Lean.Elab.Term.PostponeBehavior.partial = 1 |
_private.Batteries.Data.List.Perm.0.List.Perm.idxBij_leftInverse_idxBij_symm._proof_1_15 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs ys : List α} (h : xs.Perm ys) (w : Fin ys.length)
(h_1 : List.countBefore xs[⋯.idxBij w] xs ↑(⋯.idxBij w) + 1 ≤ (List.filter (fun x => x == xs[⋯.idxBij w]) ys).length),
(List.findIdxs (fun x => x == xs[⋯.idxBij w]) ys)[List.countBefore xs[⋯.idxBij w] xs ↑(⋯.idxBij w)] < ys.length |
AddCommGrpCat.instCreatesColimitsOfSizeUliftFunctor | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.CreatesColimitsOfSize.{w, u, u, max u v, u + 1, max (u + 1) (v + 1)} AddCommGrpCat.uliftFunctor |
FloorRing.ofFloor._proof_1 | Mathlib.Algebra.Order.Floor.Defs | ∀ (α : Type u_1) [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (floor : α → ℤ),
GaloisConnection Int.cast floor → ∀ (a : α) (z : ℤ), (fun a => -floor (-a)) a ≤ z ↔ a ≤ ↑z |
Units.coe_smul | Mathlib.Algebra.Group.Action.Units | ∀ {M : Type u_6} {N : Type u_7} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : MulDistribMulAction M N] (m : M)
(u : Nˣ), ↑(m • u) = m • ↑u |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.processAssignmentFOApproxAux | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Lean.Expr → Lean.MetaM Bool |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.applyCoe | Lean.Elab.Extra | Lean.Elab.Term.Op.Tree✝ → Lean.Expr → Bool → Lean.Elab.TermElabM Lean.Elab.Term.Op.Tree✝¹ |
Nat.lt_sum_ge | Batteries.Data.Nat.Lemmas | (a b : ℕ) → a < b ⊕' b ≤ a |
CategoryTheory.ShortComplex.SnakeInput.functorL₃_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorL₃.obj S = S.L₃ |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremAndSuggest.match_5 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Unit × Lean.Meta.Grind.SelectM.State✝ → Sort u_1) →
(__discr : Unit × Lean.Meta.Grind.SelectM.State✝¹) →
((fst : Unit) → (s : Lean.Meta.Grind.SelectM.State✝²) → motive (fst, s)) → motive __discr |
CircleDeg1Lift.monotone | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Monotone ⇑f |
CategoryTheory.Pretriangulated.Triangle.functorHomMk._proof_1 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(hom₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ⟶ B.comp CategoryTheory.Pretriangulated.Triangle.π₁)
(hom₂ : A.comp CategoryTheory.Pretriangulated.Triangle.π₂ ⟶ B.comp CategoryTheory.Pretriangulated.Triangle.π₂)
(hom₃ : A.comp CategoryTheory.Pretriangulated.Triangle.π₃ ⟶ B.comp CategoryTheory.Pretriangulated.Triangle.π₃)
(comm₁ :
CategoryTheory.CategoryStruct.comp (A.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₁Toπ₂) hom₂ =
CategoryTheory.CategoryStruct.comp hom₁ (B.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₁Toπ₂))
(comm₂ :
CategoryTheory.CategoryStruct.comp (A.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₂Toπ₃) hom₃ =
CategoryTheory.CategoryStruct.comp hom₂ (B.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₂Toπ₃))
(comm₃ :
CategoryTheory.CategoryStruct.comp (A.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₃Toπ₁)
(CategoryTheory.Functor.whiskerRight hom₁ (CategoryTheory.shiftFunctor C 1)) =
CategoryTheory.CategoryStruct.comp hom₃ (B.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₃Toπ₁))
(x x_1 : J) (φ : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp (A.map φ)
{ hom₁ := hom₁.app x_1, hom₂ := hom₂.app x_1, hom₃ := hom₃.app x_1, comm₁ := ⋯, comm₂ := ⋯, comm₃ := ⋯ } =
CategoryTheory.CategoryStruct.comp
{ hom₁ := hom₁.app x, hom₂ := hom₂.app x, hom₃ := hom₃.app x, comm₁ := ⋯, comm₂ := ⋯, comm₃ := ⋯ } (B.map φ) |
Ideal.map_pi | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [inst : Ring R] (I : Ideal R) [I.IsTwoSided] [Finite ι] (x : ι → R),
(∀ (i : ι), x i ∈ I) → ∀ (f : (ι → R) →ₗ[R] ι' → R) (i : ι'), f x i ∈ I |
ENat.pow_ne_top_iff | Mathlib.Data.ENat.Basic | ∀ {a : ℕ∞} {n : ℕ}, a ^ n ≠ ⊤ ↔ a ≠ ⊤ ∨ n = 0 |
Nat.count_strict_mono | Mathlib.Data.Nat.Count | ∀ {p : ℕ → Prop} [inst : DecidablePred p] {m n : ℕ}, p m → m < n → Nat.count p m < Nat.count p n |
Function.Embedding.twoEmbeddingEquiv.match_1 | Mathlib.Data.Fin.Tuple.Embedding | {α : Type u_1} → (motive : α × α → Sort u_2) → (x : α × α) → ((a b : α) → motive (a, b)) → motive x |
EMetric.ball_subset | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε₁ ε₂ : ENNReal},
edist x y + ε₁ ≤ ε₂ → edist x y ≠ ⊤ → Metric.eball x ε₁ ⊆ Metric.eball y ε₂ |
_private.Mathlib.NumberTheory.Padics.ProperSpace.0.PadicInt.totallyBounded_univ._simp_1_5 | Mathlib.NumberTheory.Padics.ProperSpace | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop}, (∃ y ∈ f '' s, p y) = ∃ x ∈ s, p (f x) |
_private.Mathlib.Tactic.NormNum.Eq.0.Mathlib.Meta.NormNum.evalEq.match_8 | Mathlib.Tactic.NormNum.Eq | (u : Lean.Level) →
(α :
have u := u;
Q(Type u)) →
(dsα : Q(DivisionSemiring «$α»)) →
(motive : Option Q(CharZero «$α») → Sort u_1) →
(__do_lift : Option Q(CharZero «$α»)) →
((_i : Q(CharZero «$α»)) → motive (some _i)) → ((x : Option Q(CharZero «$α»)) → motive x) → motive __do_lift |
Vector.findSomeRev? | Init.Data.Vector.Basic | {α : Type u_1} → {β : Type u_2} → {n : ℕ} → (α → Option β) → Vector α n → Option β |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_succ_left_eq_erase_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) |
ProofWidgets.RpcEncodablePacket.mk.injEq._@.ProofWidgets.Presentation.Expr.3227936355._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | ∀ (expr expr_1 : Lean.Json), ({ expr := expr } = { expr := expr_1 }) = (expr = expr_1) |
_private.Mathlib.Topology.Algebra.Module.PointwiseConvergence.0.PointwiseConvergenceCLM.tendsto_iff_forall_tendsto._simp_1_1 | Mathlib.Topology.Algebra.Module.PointwiseConvergence | ∀ {Y : Type v} {ι : Type u_5} {A : ι → Type u_6} [T : (i : ι) → TopologicalSpace (A i)] {f : Y → (i : ι) → A i}
{g : (i : ι) → A i} {u : Filter Y},
Filter.Tendsto f u (nhds g) = ∀ (x : ι), Filter.Tendsto (fun i => f i x) u (nhds (g x)) |
HasSum.smul_eq | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_5} {κ : Type u_6} {R : Type u_7} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace M] [T3Space M] [ContinuousAdd M]
[ContinuousSMul R M] {f : ι → R} {g : κ → M} {s : R} {t u : M},
HasSum f s → HasSum g t → HasSum (fun x => f x.1 • g x.2) u → s • t = u |
NormedStarGroup.rec | Mathlib.Analysis.CStarAlgebra.Basic | {E : Type u_1} →
[inst : SeminormedAddCommGroup E] →
[inst_1 : StarAddMonoid E] →
{motive : NormedStarGroup E → Sort u} →
((norm_star_le : ∀ (x : E), ‖star x‖ ≤ ‖x‖) → motive ⋯) → (t : NormedStarGroup E) → motive t |
HomotopicalAlgebra.Precylinder.mk.inj | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {A I : C} {i₀ i₁ : A ⟶ I} {π : I ⟶ A}
{i₀_π :
autoParam (CategoryTheory.CategoryStruct.comp i₀ π = CategoryTheory.CategoryStruct.id A)
HomotopicalAlgebra.Precylinder.i₀_π._autoParam}
{i₁_π :
autoParam (CategoryTheory.CategoryStruct.comp i₁ π = CategoryTheory.CategoryStruct.id A)
HomotopicalAlgebra.Precylinder.i₁_π._autoParam}
{I_1 : C} {i₀_1 i₁_1 : A ⟶ I_1} {π_1 : I_1 ⟶ A}
{i₀_π_1 :
autoParam (CategoryTheory.CategoryStruct.comp i₀_1 π_1 = CategoryTheory.CategoryStruct.id A)
HomotopicalAlgebra.Precylinder.i₀_π._autoParam}
{i₁_π_1 :
autoParam (CategoryTheory.CategoryStruct.comp i₁_1 π_1 = CategoryTheory.CategoryStruct.id A)
HomotopicalAlgebra.Precylinder.i₁_π._autoParam},
{ I := I, i₀ := i₀, i₁ := i₁, π := π, i₀_π := i₀_π, i₁_π := i₁_π } =
{ I := I_1, i₀ := i₀_1, i₁ := i₁_1, π := π_1, i₀_π := i₀_π_1, i₁_π := i₁_π_1 } →
I = I_1 ∧ i₀ ≍ i₀_1 ∧ i₁ ≍ i₁_1 ∧ π ≍ π_1 |
HasCardinalLT.Set.cocone_ι_app | Mathlib.CategoryTheory.Presentable.Type | ∀ (X : Type u) (κ : Cardinal.{u}) (x : HasCardinalLT.Set X κ) (self : { x_1 // x_1 ∈ ⋯.functor.obj x }),
(HasCardinalLT.Set.cocone X κ).ι.app x self = ↑self |
Equiv.prodUnique_symm_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} [inst : Unique β] (x : α), (Equiv.prodUnique α β).symm x = (x, default) |
MeasureTheory.Measure.sum_eq_zero | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} {f : ι → MeasureTheory.Measure α},
MeasureTheory.Measure.sum f = 0 ↔ ∀ (i : ι), f i = 0 |
Turing.PartrecToTM2.natEnd | Mathlib.Computability.TMToPartrec | Turing.PartrecToTM2.Γ' → Bool |
Lean.addTraceAsMessages | Lean.Util.Trace | {m : Type → Type} →
[Lean.MonadOptions m] → [Monad m] → [Lean.MonadRef m] → [Lean.MonadLog m] → [Lean.MonadTrace m] → m Unit |
Real.exp_one_rpow | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ), Real.exp 1 ^ x = Real.exp x |
CategoryTheory.Presheaf.restrictedULiftYonedaHomEquiv' | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{ℰ : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ] →
(A : CategoryTheory.Functor C ℰ) →
(P : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) →
(E : ℰ) →
((CategoryTheory.CostructuredArrow.proj CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁} P).comp A ⟶
(CategoryTheory.Functor.const
(CategoryTheory.CostructuredArrow CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁} P)).obj
E) ≃
(P ⟶ (CategoryTheory.Presheaf.restrictedULiftYoneda A).obj E) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.