name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
continuous_cfcₙHom_of_cfcHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Ring A] [inst_6 : StarRing A]
[inst_7 : TopologicalSpace A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p]... | true |
Int16.ne_of_lt | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, a < b → a ≠ b | true |
Lean.Meta.Try.Collector.OrdSet.rec | Lean.Meta.Tactic.Try.Collect | {α : Type} →
[inst : Hashable α] →
[inst_1 : BEq α] →
{motive : Lean.Meta.Try.Collector.OrdSet α → Sort u} →
((elems : Array α) → (set : Std.HashSet α) → motive { elems := elems, set := set }) →
(t : Lean.Meta.Try.Collector.OrdSet α) → motive t | false |
_private.Lean.Elab.Tactic.Grind.Lint.0.Lean.Elab.Tactic.Grind.elabGrindLintInspect | Lean.Elab.Tactic.Grind.Lint | Lean.Elab.Command.CommandElab | true |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.isDone | Lean.Meta.Match.SimpH | Lean.Meta.Match.SimpH.M✝ Bool | true |
Nat.and_distrib_right | Init.Data.Nat.Bitwise.Lemmas | ∀ (x y z : ℕ), (x ||| y) &&& z = x &&& z ||| y &&& z | true |
CategoryTheory.Functor.IsCardinalAccessible.recOn | Mathlib.CategoryTheory.Presentable.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{κ : Cardinal.{w}} →
[inst_2 : Fact κ.IsRegular] →
{motive : F.IsCardinalAccessible κ → Sort u} →
... | false |
_private.Mathlib.Algebra.Lie.BaseChange.0.LieAlgebra.ExtendScalars.bracket'._proof_5 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
IsScalarTower R A (TensorProduct A A A) | false |
_private.Lean.Meta.Match.CaseValues.0.Lean.Meta.caseValues.loop._sparseCasesOn_3 | Lean.Meta.Match.CaseValues | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
_private.Init.Omega.IntList.0.List.getElem?_zipWith.match_1.splitter | Init.Omega.IntList | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → Option β → Sort u_3) →
(x : Option α) →
(x_1 : Option β) →
((a : α) → (b : β) → motive (some a) (some b)) →
((x : Option α) →
(x_2 : Option β) → (∀ (a : α) (b : β), x = some a → x_2 = some b → False) → motiv... | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.toInductive | Lean.Meta.MkIffOfInductiveProp | Lean.MVarId → List Lean.Name → List Lean.Expr → List Lean.Meta.Shape✝ → Lean.FVarId → Lean.MetaM Unit | true |
ArchimedeanClass.closedBall_top | Mathlib.Algebra.Order.Module.Archimedean | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M], ArchimedeanClass.closedBall K ⊤ = ⊥ | true |
Path.Homotopy.symm₂._proof_3 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁} (F : p.Homotopy q) (x : ↑unitInterval),
F ((0, x).1, unitInterval.symm (0, x).2) = p.symm.toContinuousMap x | false |
ProbabilityTheory.IdentDistrib.measure_preimage_eq | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ},
ProbabilityTheory.IdentDistrib f g μ ν → ∀ {s : Set γ}, MeasurableSet s → μ (f ⁻¹' s) = ν (g ⁻¹' s) | true |
_private.Mathlib.Data.Finsupp.MonomialOrder.DegLex.0.Finsupp.DegLex.single_strictAnti._simp_1_1 | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False | false |
NNReal.iSup_eq_zero | Mathlib.Data.NNReal.Defs | ∀ {ι : Sort u_1} {f : ι → NNReal}, BddAbove (Set.range f) → (⨆ i, f i = 0 ↔ ∀ (i : ι), f i = 0) | true |
DFinsupp.toMultiset_toDFinsupp | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (f : Π₀ (x : α), ℕ), Multiset.toDFinsupp (DFinsupp.toMultiset f) = f | true |
_private.Mathlib.SetTheory.Cardinal.Finite.0.Nat.card_ne_zero._simp_1_2 | Mathlib.SetTheory.Cardinal.Finite | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | false |
Int.Linear.le_of_le_diseq_cert.eq_1 | Init.Data.Int.Linear | ∀ (p₁ p₂ p₃ : Int.Linear.Poly),
Int.Linear.le_of_le_diseq_cert p₁ p₂ p₃ = (p₂.beq' p₁ || p₂.beq' (p₁.mul_k (-1))).and' (p₃.beq' (p₁.addConst_k 1)) | true |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MvPolynomial.idealOfVars_eq_restrictSupportIdeal._simp_1_4 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.ProofM.State.varDecls' | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Lean.Meta.Grind.Arith.Cutsat.ProofM.State✝ → Std.HashMap Int.Linear.Var Lean.Expr | true |
Cycle.coe_eq_coe._simp_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ = ↑l₂) = (l₁ ~r l₂) | false |
NonUnitalSubring.toNonUnitalSubsemiring_strictMono | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R], StrictMono NonUnitalSubring.toNonUnitalSubsemiring | true |
ZeroAtInftyContinuousMap.instNormedAddCommGroup._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedAddCommGroup β],
autoParam (∀ (x y : ZeroAtInftyContinuousMap α β), dist x y = ‖-x + y‖) NormedAddCommGroup.dist_eq._autoParam | false |
RingHom.coe_rangeRestrict | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R →+* S) (x : R),
↑(f.rangeRestrict x) = f x | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateBoxImp._sparseCasesOn_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((ty : Lean.Expr) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.box ty fvarId h)) →
(Nat... | false |
CategoryTheory.GradedNatTrans | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.EnrichedCategory V D] →
CategoryTheory.Center V →
... | true |
CategoryTheory.Mat_.lift_map | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
{X Y... | true |
Batteries.Random.MersenneTwister.State.mk.inj | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} {data : Vector (BitVec cfg.wordSize) cfg.stateSize}
{index : Fin cfg.stateSize} {data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize} {index_1 : Fin cfg.stateSize},
{ data := data, index := index } = { data := data_1, index := index_1 } → data = data_1 ∧ index = ind... | true |
CategoryTheory.Functor.Final.coconesEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_2}
[inst_3 : CategoryTheory.Category.{u_1, u_2} E] (G : CategoryTheory.Functor D E)
(c : CategoryTheory.Limits.Cocone (F.com... | false |
MeasurableEmbedding.map_withDensity_rnDeriv | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β},
MeasurableEmbedding f →
∀ (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ] [MeasureTheory.SigmaFinite ν],
MeasureTheory.Measure.map f (ν.withDensity (μ.rnDeriv ν)) =
(MeasureTheory.Measure.map ... | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.isInvalidContinuationByte_getElem_utf8EncodeChar_one_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (hc : c.utf8Size = 2),
ByteArray.utf8DecodeChar?.isInvalidContinuationByte (String.utf8EncodeChar c)[1] = false | true |
Subgroup.IsArithmetic.conj | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)) [𝒢.IsArithmetic] (g : GL (Fin 2) ℚ),
(ConjAct.toConjAct ((Matrix.GeneralLinearGroup.map (Rat.castHom ℝ)) g) • 𝒢).IsArithmetic | true |
CategoryTheory.Triangulated.Octahedron.map._proof_5 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : ∀ (n : ℤ), ... | false |
Subalgebra.toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → Subalgebra R A ↪o Submodule R A | true |
UInt64.ofNat | Init.Data.UInt.BasicAux | ℕ → UInt64 | true |
GenContFract.first_cont_eq | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K] {gp : GenContFract.Pair K},
g.s.get? 0 = some gp → g.conts 1 = { a := gp.b * g.h + gp.a, b := gp.b } | true |
realPart_one | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : StarRing A] [inst_2 : Module ℂ A] [inst_3 : StarModule ℂ A], realPart 1 = 1 | true |
IsRightUniformGroup.toIsTopologicalGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {G : Type u_7} {inst : UniformSpace G} {inst_1 : Group G} [self : IsRightUniformGroup G], IsTopologicalGroup G | true |
Std.DTreeMap.Internal.Impl.Const.get!_insertManyIfNewUnit_empty_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get!
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit Std.DTreeMap.Internal.Impl.empty l ⋯)) k =
() | true |
Lean.Meta.LazyDiscrTree.Cache.rec | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Cache → Sort u} →
((ngen : Lean.NameGenerator) →
(core : Lean.Core.Cache) → («meta» : Lean.Meta.Cache) → motive { ngen := ngen, core := core, «meta» := «meta» }) →
(t : Lean.Meta.LazyDiscrTree.Cache) → motive t | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldlM.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldlM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← f x a b
Std.DHashMap.... | true |
Finsupp.some_zero | Mathlib.Data.Finsupp.Option | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M], Finsupp.some 0 = 0 | true |
CategoryTheory.Pi.ext | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type w₀} (C : I → Type u₁) [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i}
{f g : X ⟶ Y}, (∀ (i : I), f i = g i) → f = g | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.empty_isBase_iff._simp_1_4 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M₁ M₂ : Matroid α}, (M₁ = M₂) = (M₁.E = M₂.E ∧ ∀ ⦃I : Set α⦄, I ⊆ M₁.E → (M₁.Indep I ↔ M₂.Indep I)) | false |
chart_mem_atlas | Mathlib.Geometry.Manifold.ChartedSpace | ∀ (H : Type u_5) {M : Type u_6} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(x : M), chartAt H x ∈ atlas H M | true |
Lean.Meta.SparseCasesOnInfo.recOn | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnInfo → Sort u} →
(t : Lean.Meta.SparseCasesOnInfo) →
((indName : Lean.Name) →
(majorPos arity : ℕ) →
(insterestingCtors : Array Lean.Name) →
motive
{ indName := indName, majorPos := majorPos, arity := arity, insterestingCtors := insteres... | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabFunValues.match_5 | Lean.Elab.MutualDef | (motive : Option (Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot)) → Sort u_1) →
(x : Option (Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot))) →
((snap : Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot)) → motive (some snap)) →
((x : Option (... | false |
AddCommGroup.nsmul_add_modEq | Mathlib.Algebra.Group.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoid M] {a p : M} (n : ℕ), n • p + a ≡ a [PMOD p] | true |
Mathlib.Tactic.Widget.StringDiagram.Node.recOn | Mathlib.Tactic.Widget.StringDiagram | {motive : Mathlib.Tactic.Widget.StringDiagram.Node → Sort u} →
(t : Mathlib.Tactic.Widget.StringDiagram.Node) →
((a : Mathlib.Tactic.Widget.StringDiagram.AtomNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.atom a)) →
((a : Mathlib.Tactic.Widget.StringDiagram.IdNode) → motive (Mathlib.Tactic.Widget.... | false |
SimpleGraph.Hom.toCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {α : Type u_4} →
{β : Type u_5} → {A : SimpleGraph α} → {B : SimpleGraph β} → (f : A →g B) → Function.Injective ⇑f → A.Copy B | true |
List.forIn'_pure_yield_eq_foldl | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {l : List α}
(f : (a : α) → a ∈ l → β → β) (init : β),
(forIn' l init fun a m_1 b => pure (ForInStep.yield (f a m_1 b))) =
pure
(List.foldl
(fun b x =>
match x with
| ⟨a, h⟩ => f a h b)
... | true |
LieSubalgebra.mem_normalizer_iff' | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (x : L), x ∈ H.normalizer ↔ ∀ y ∈ H, ⁅y, x⁆ ∈ H | true |
Cardinal.mk_univ_real | Mathlib.Analysis.Real.Cardinality | Cardinal.mk ↑Set.univ = Cardinal.continuum | true |
Lean.Grind.CommRing.Expr._sizeOf_inst | Init.Grind.Ring.CommSolver | SizeOf Lean.Grind.CommRing.Expr | false |
LieRinehartAlgebra | Mathlib.Algebra.LieRinehartAlgebra.Defs | (R : Type u_1) →
(A : Type u_2) →
(L : Type u_3) →
[inst : CommRing A] →
[inst_1 : LieRing L] →
[inst_2 : Module A L] →
[inst_3 : LieRingModule L A] →
[LieRinehartRing A L] → [inst_5 : CommRing R] → [Algebra R A] → [LieAlgebra R L] → Prop | true |
Aesop.FVarIdSubst.ctorIdx | Aesop.RuleTac.FVarIdSubst | Aesop.FVarIdSubst → ℕ | false |
MeasureTheory.average | Mathlib.MeasureTheory.Integral.Average | {α : Type u_1} →
{E : Type u_2} →
{m0 : MeasurableSpace α} → [inst : NormedAddCommGroup E] → [NormedSpace ℝ E] → MeasureTheory.Measure α → (α → E) → E | true |
MvPowerSeries.X_dvd_iff | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {s : σ} {φ : MvPowerSeries σ R},
MvPowerSeries.X s ∣ φ ↔ ∀ (m : σ →₀ ℕ), m s = 0 → (MvPowerSeries.coeff m) φ = 0 | true |
intervalIntegral.integral_hasDerivAt_of_tendsto_ae_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {c : E}
{a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
Filter.Tendsto f (nhds b ⊓ MeasureTheory.ae MeasureTheory.volume) (nhds c)... | true |
_private.Mathlib.RingTheory.WittVector.WittPolynomial.0.xInTermsOfW_vars_aux._proof_1_3 | Mathlib.RingTheory.WittVector.WittPolynomial | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], NeZero p | false |
LinearMap.range_eq_top_of_surjective | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂), Function.Surjective ⇑f → f.range = ⊤ | true |
_private.Lean.Data.PersistentArray.0.Lean.PersistentArray.foldlMAux.match_1 | Lean.Data.PersistentArray | {α : Type u_1} →
{β : Type u_3} →
(motive : Lean.PersistentArrayNode α → β → Sort u_2) →
(x : Lean.PersistentArrayNode α) →
(x_1 : β) →
((cs : Array (Lean.PersistentArrayNode α)) → (b : β) → motive (Lean.PersistentArrayNode.node cs) b) →
((vs : Array α) → (b : β) → motive (Lean... | false |
AnalyticAt.fun_pow | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {A : Type u_7} [inst_3 : NormedRing A] [inst_4 : NormedAlgebra 𝕜 A] {f : E → A} {z : E},
AnalyticAt 𝕜 f z → ∀ (n : ℕ), AnalyticAt 𝕜 (fun i => f i ^ n) z | true |
RootPairing.flipEquiv._proof_1 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ (ι : Type u_1) (R : Type u_2) (M : Type u_3) (N : Type u_4) [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N],
Function.LeftInverse (fun P => P.flip) fun P => P.flip | false |
Affine.Simplex.sum_excenterWeights | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1)))
[inst_5 : Decidable (s.ExcenterExists signs)],
∑ i, s.excenterWeights signs i... | true |
IsBaseChange.directSumPow | Mathlib.RingTheory.TensorProduct.IsBaseChangePi | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (ι : Type u_3)
{M : Type u_6} {M' : Type u_7} [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M'] [inst_5 : Module R M]
[inst_6 : Module R M'] [inst_7 : Module S M'] [inst_8 : IsScalarTower R S M'] {ε : M →ₗ[... | true |
RingCon.instRingQuotient._proof_8 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Ring R] (c : RingCon R), Function.Surjective Quotient.mk'' | false |
ProbabilityTheory.condIndepFun_iff_condExp_inter_preimage_eq_mul | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'},
Measurable f →
Measurable g →
(... | true |
CategoryTheory.Bimon.instBimonObjXXMon | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (M : CategoryTheory.Bimon C) → CategoryTheory.BimonObj M.X.X | true |
CommMonCat.units._proof_1 | Mathlib.Algebra.Category.Grp.Adjunctions | ∀ (x : CommMonCat),
CommGrpCat.ofHom (Units.map (CommMonCat.Hom.hom (CategoryTheory.CategoryStruct.id x))) =
CategoryTheory.CategoryStruct.id (CommGrpCat.of (↑x)ˣ) | false |
sub_one_mul_padicValNat_choose_eq_sub_sum_digits' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p k n : ℕ} [hp : Fact (Nat.Prime p)],
(p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum | true |
CategoryTheory.Endofunctor.Coalgebra.Hom.id._proof_2 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
(V : CategoryTheory.Endofunctor.Coalgebra F),
CategoryTheory.CategoryStruct.comp V.str (F.map (CategoryTheory.CategoryStruct.id V.V)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id V.V) V.str | false |
_private.Mathlib.Topology.Constructions.SumProd.0.isOpenMap_inr._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s = (IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)) | false |
DiscreteQuotient.equivFinsetClopens | Mathlib.Topology.DiscreteQuotient | (X : Type u_2) →
[inst : TopologicalSpace X] →
[inst_1 : CompactSpace X] → DiscreteQuotient X ≃ ↑(Set.range (DiscreteQuotient.finsetClopens X)) | true |
ULiftable.up' | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} → {g : Type v₀ → Type v₁} → [ULiftable f g] → f PUnit.{u₀ + 1} → g PUnit.{v₀ + 1} | true |
List.pmap_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {p : { x // x ∈ l } → Prop} {f : (a : { x // x ∈ l }) → p a → β}
(H : ∀ a ∈ l.attach, p a), List.pmap f l.attach H = List.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) l ⋯ | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.errorMessage.match_6 | Mathlib.Tactic.Linter.TextBased | (motive : Mathlib.Linter.TextBased.StyleError✝ → Sort u_1) →
(err : Mathlib.Linter.TextBased.StyleError✝¹) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.adaptationNote✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.windowsLineEnding✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleErr... | false |
CategoryTheory.PreOneHypercover.inv_hom_h₁_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : F.I₀} (k : F.I₁ i j) {Z : C} (h : F.Y (e.hom.s₁ (e.inv.s₁ k)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₁ k) (CategoryTheory.CategoryStruct.comp (e.hom.h₁ (e.inv.s₁ k)) h) =
Categ... | true |
Real.RingHom.unique | Mathlib.Data.Real.Hom | Unique (ℝ →+* ℝ) | true |
ContinuousCohomology.continuousCohomologyZeroIso._proof_3 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_3) (G : Type u_1) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] {X Y : Action (TopModuleCat R) G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((continuousCohomology R G 0).map f)
((fun X =>
(Cate... | false |
Metric.exists_isBounded_image_of_tendsto | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_3} {β : Type u_4} [inst : PseudoMetricSpace β] {l : Filter α} {f : α → β} {x : β},
Filter.Tendsto f l (nhds x) → ∃ s ∈ l, Bornology.IsBounded (f '' s) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_filter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Lean.IR.UnboxResult.unboxAttr._regBuiltin.Lean.IR.UnboxResult.unboxAttr.docString_1 | Lean.Compiler.IR.UnboxResult | IO Unit | false |
LieModule.rank_le_finrank | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : LieRingModule L M] [inst_8 : LieModule R L M] [inst_9 : Module.Finite R M] [inst_10 : Mo... | true |
Set.Finite.isGδ_compl | Mathlib.Topology.Separation.GDelta | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} [T1Space X], s.Finite → IsGδ sᶜ | true |
LieAlgebra.Orthogonal.typeB | Mathlib.Algebra.Lie.Classical | (l : Type u_4) →
(R : Type u₂) →
[inst : DecidableEq l] →
[inst_1 : CommRing R] → [inst_2 : Fintype l] → LieSubalgebra R (Matrix (Unit ⊕ l ⊕ l) (Unit ⊕ l ⊕ l) R) | true |
CategoryTheory.Over.opEquivOpUnder._proof_4 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) {Z Y : (CategoryTheory.Under X)ᵒᵖ} (f : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp f.unop.right.op (CategoryTheory.Over.mk (Opposite.unop Y).hom.op).hom =
(CategoryTheory.Over.mk (Opposite.unop Z).hom.op).hom | false |
Array.PrefixTable.step | Batteries.Data.Array.Match | {α : Type u_1} → [BEq α] → (t : Array.PrefixTable α) → α → Fin (t.size + 1) → Fin (t.size + 1) | true |
Finset.sigmaLift | Mathlib.Data.Finset.Sigma | {ι : Type u_1} →
{α : ι → Type u_2} →
{β : ι → Type u_3} →
{γ : ι → Type u_4} → [DecidableEq ι] → (⦃i : ι⦄ → α i → β i → Finset (γ i)) → Sigma α → Sigma β → Finset (Sigma γ) | true |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_map_app_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) {X_1 Y : CategoryTheory.Functor J₂ C}
(f : X_1 ⟶ Y)... | true |
Std.TreeMap.Raw.Equiv.minEntry?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.minEntry? = t₂.minEntry? | true |
MeasureTheory.lintegral_liminf_le' | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : ℕ → α → ENNReal},
(∀ (n : ℕ), AEMeasurable (f n) μ) →
∫⁻ (a : α), Filter.liminf (fun n => f n a) Filter.atTop ∂μ ≤
Filter.liminf (fun n => ∫⁻ (a : α), f n a ∂μ) Filter.atTop | true |
SimpleGraph.killCopies.edgeSet.instFintype | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} →
{W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → [Fintype ↑G.edgeSet] → Fintype ↑(G.killCopies H).edgeSet | true |
CategoryTheory.ObjectProperty.strictColimitsOfShape_bot | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [Nonempty J], ⊥.strictColimitsOfShape J = ⊥ | true |
HasSummableGeomSeries.rec | Mathlib.Analysis.SpecificLimits.Normed | {K : Type u_4} →
[inst : NormedRing K] →
{motive : HasSummableGeomSeries K → Sort u} →
((summable_geometric_of_norm_lt_one : ∀ (ξ : K), ‖ξ‖ < 1 → Summable fun n => ξ ^ n) → motive ⋯) →
(t : HasSummableGeomSeries K) → motive t | false |
HNNExtension.NormalWord.ReducedWord.prod.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) (w : HNNExtension.NormalWord.ReducedWord G A B),
HNNExtension.NormalWord.ReducedWord.prod φ w =
HNNExtension.of w.head * (List.map (fun x => HNNExtension.t ^ ↑x.1 * HNNExtension.of x.2) w.toList).prod | true |
SeparationQuotient.instMulZeroOneClass._proof_3 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M₀ : Type u_1} [inst : TopologicalSpace M₀] [inst_1 : MulZeroOneClass M₀] [inst_2 : ContinuousMul M₀] (a b : M₀),
SeparationQuotient.mk (a * b) = SeparationQuotient.mk a * SeparationQuotient.mk b | false |
_private.Mathlib.Probability.Distributions.Gaussian.Multivariate.0.ProbabilityTheory.charFun_stdGaussian._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ (r : ℝ) (n : ℕ), ↑r ^ n = ↑(r ^ n) | false |
MeasureTheory.Filtration.mono | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {i j : ι}
(f : MeasureTheory.Filtration ι m), i ≤ j → ↑f i ≤ ↑f j | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.