name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LieAlgebra.IsKilling.lieIdealOrderIso._proof_2 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] [inst_5 : LieAlgebra.IsKilling K L] (H : LieSubalgebra K L)
[inst_6 : H.IsCartanSubalgebra] [inst_7 : LieModule.IsTriangularizable K (↥H) L]
(q : ↥(LieAlgebra.IsKi... | null | false |
_private.Mathlib.FieldTheory.Finite.Valuation.0.FiniteField.valuation_algebraMap_le_one._proof_1_1 | Mathlib.FieldTheory.Finite.Valuation | ∀ {Fq : Type u_3} {A : Type u_2} {Γ : Type u_1} [inst : Field Fq] [inst_1 : Ring A] [inst_2 : Algebra Fq A]
[inst_3 : LinearOrderedCommMonoidWithZero Γ] (v : Valuation A Γ) (a : Fq), a = 0 → v ((algebraMap Fq A) a) ≤ 1 | null | false |
FunctionField.valuedFqtInfty._proof_1 | Mathlib.NumberTheory.FunctionField | IsOrderedMonoid (Multiplicative ℤ) | null | false |
Std.ExtHashMap.getKey.congr_simp | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtHashMap α β) (e_m : m = m_1) (a a_1 : α) (e_a : a = a_1) (h : a ∈ m), m.getKey a h = m_1.getKey a_1 ⋯ | null | true |
IsIsometricVAdd | Mathlib.Topology.MetricSpace.IsometricSMul | (M : Type u) → (X : Type w) → [PseudoEMetricSpace X] → [VAdd M X] → Prop | An additive action is isometric if each map `x ↦ c +ᵥ x` is an isometry. | true |
AddCon.instDecidableEqQuotientOfDecidableCoeForallProp | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} → [inst : Add M] → (c : AddCon M) → [(a b : M) → Decidable (c a b)] → DecidableEq c.Quotient | The quotient by a decidable additive congruence relation has decidable equality. | true |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryThe... | The natural map `Φ.X₀ ⟶ (Φ.iterationFunctor J).obj j`. | true |
CategoryTheory.sectionsFunctorNatIsoCoyoneda._proof_1 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Type (max u_2 u_3)) [inst_1 : Unique X]
{X_1 Y : CategoryTheory.Functor C (Type (max u_2 u_3))} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.sectionsFunctor C).map f)
(Y.sectionsEquivHom X).toIso.hom =
Catego... | null | false |
CategoryTheory.ObjectProperty.prop_X₁_of_shortExact | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderSubobjects] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C},
S.ShortExact → P S.X₂ → P S.X₁ | null | true |
groupHomology.H2π_comp_map | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
CategoryTheory.CategoryStruct.comp (groupHomology.H2π A) (groupHomology.map f φ 2) =
CategoryTheory.CategoryStruct.comp (groupHomology.mapCycles₂ f φ) ... | null | true |
Std.IterM.TerminationMeasures.Productive.mk.noConfusion | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{inst : Std.Iterator α m β} →
{P : Sort u} → {it it' : Std.IterM m β} → { it := it } = { it := it' } → (it ≍ it' → P) → P | null | false |
_private.Mathlib.CategoryTheory.Localization.CalculusOfFractions.0.CategoryTheory.MorphismProperty.LeftFraction.map_compatibility._simp_1_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
Complex.le_def | Mathlib.Analysis.Complex.Order | ∀ {z w : ℂ}, z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im | null | true |
WithTop.zero.eq_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α], WithTop.zero = { zero := ↑0 } | null | true |
Polynomial.IsDistinguishedAt.casesOn | Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished | {R : Type u_1} →
[inst : CommRing R] →
{f : Polynomial R} →
{I : Ideal R} →
{motive : f.IsDistinguishedAt I → Sort u} →
(t : f.IsDistinguishedAt I) →
((toIsWeaklyEisensteinAt : f.IsWeaklyEisensteinAt I) → (monic : f.Monic) → motive ⋯) → motive t | null | false |
Lean.Elab.Tactic.withMacroExpansion | Lean.Elab.Tactic.Basic | {α : Type} → Lean.Syntax → Lean.Syntax → Lean.Elab.Tactic.TacticM α → Lean.Elab.Tactic.TacticM α | Elaborate `x` with `stx` on the macro stack | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_9 | Lean.Compiler.NameMangling | ∀ (s : String) (p : s.Pos) (res : Lean.Name) (h : ¬p = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x =>
PSigma.casesOn ... | null | false |
Std.Internal.List.getKey_minKey!_eq_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {he : Std.Internal.List.containsKey (Std.Internal.List.minKey! l) l = true},
Std.Internal.List.getKey (Std.Internal.... | null | true |
ComplexShape.instAssociative | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I : Type u_7} [inst : AddMonoid I] (c : ComplexShape I) [inst_1 : c.TensorSigns], c.Associative c c c c c | null | true |
Measure.eq_prod_of_integral_mul_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {Z : Type u_3} {T : Type u_4} {mZ : MeasurableSpace Z} [inst : TopologicalSpace Z] [BorelSpace Z]
[HasOuterApproxClosed Z] {mT : MeasurableSpace T} [inst_3 : TopologicalSpace T] [BorelSpace T]
[HasOuterApproxClosed T] {μ : MeasureTheory.Measure Z} {ν : MeasureTheory.Measure T}
{ξ : MeasureTheory.Measure (Z × T)... | The product of two finite measures `μ` and `ν` is the only finite measure `ξ` such that
for all real bounded continuous functions `f` and `g` we have
`∫ z, f z.1 * g z.2 ∂ξ = ∫ x, f x ∂μ * ∫ y, g y ∂ν`. | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.«_aux_Mathlib_CategoryTheory_Monoidal_Action_Basic___macroRules_CategoryTheory_MonoidalCategory_MonoidalLeftAction_termλₗ[_]_1» | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.Macro | null | false |
ProbabilityTheory.IdentDistrib.symm | 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 μ ν → ProbabilityTheory.IdentDistrib g f ν μ | null | true |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing._unary._proof_29 | Mathlib.RingTheory.Regular.RegularSequence | ∀
(_x :
(x : Type u_1) ×'
(x_1 : CommRing x) ×'
(x_2 : Type u_2) ×'
(x_3 : AddCommGroup x_2) ×'
(x_4 : Module x x_2) ×' (x_5 : List x) ×' RingTheory.Sequence.IsWeaklyRegular x_2 x_5),
RingTheory.Sequence.IsWeaklyRegular _x.2.2.1 _x.2.2.2.2.2.1 | null | false |
CategoryTheory.Limits.factorThruKernelSubobject.congr_simp | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] {W : C} (h h_1 : W ⟶ X) (e_h : h = h_1)
(w : CategoryTheory.CategoryStruct.comp h f = 0),
CategoryTheory.Limits.factorThruKernelSubobject ... | null | true |
Prod.map_comp_swap | Init.Data.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ),
Prod.map f g ∘ Prod.swap = Prod.swap ∘ Prod.map g f | For two functions `f` and `g`, the composition of `Prod.map f g` with `Prod.swap`
is equal to the composition of `Prod.swap` with `Prod.map g f`.
| true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Char.0.String.Slice.startsWith_char_eq_head?._simp_1_8 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {l₁ l₂ : List Char}, (l₁ = l₂) = (String.ofList l₁ = String.ofList l₂) | null | false |
Std.ExtTreeMap.contains_unitOfList | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List α}
{k : α}, (Std.ExtTreeMap.unitOfList l cmp).contains k = l.contains k | null | true |
Submodule.inclusion.eq_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p p' : Submodule R M} (h : p ≤ p'), Submodule.inclusion h = LinearMap.codRestrict p' p.subtype ⋯ | null | true |
_private.Lean.Elab.Tactic.Omega.MinNatAbs.0.Lean.Elab.Tactic.Omega.List.nonzeroMinimum_eq_zero_iff._simp_1_3 | Lean.Elab.Tactic.Omega.MinNatAbs | ∀ {α : Type u_1} {xs : List α} [inst : Min α], (xs.min? = none) = (xs = []) | null | false |
SummableLocallyUniformly | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | {α : Type u_1} →
{β : Type u_2} → {ι : Type u_3} → [AddCommMonoid α] → (ι → β → α) → [UniformSpace α] → [TopologicalSpace β] → Prop | `SummableLocallyUniformly f` means that `∑' i, f i b` converges locally
uniformly to something. | true |
PNat.coe_toPNat' | Mathlib.Data.PNat.Defs | ∀ (n : ℕ+), (↑n).toPNat' = n | null | true |
Mathlib.Tactic.PNatToNat.tacticPnat_positivity | Mathlib.Tactic.PNatToNat | Lean.ParserDescr | For each `x : PNat` in the context, add the hypothesis `0 < (↑x : ℕ)`. | true |
Equiv.mul | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [Mul β] → Mul α | Transfer `Mul` across an `Equiv` | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_10 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (res : Lean.Name) (acc : String) (ucount : ℕ) (hp₀ : ¬p₀ = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x ... | null | false |
Order.isPredPrelimitRecOn._proof_3 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} (b : α) [inst : PartialOrder α] [inst_1 : PredOrder α] (hb : ¬Order.IsPredPrelimit b),
¬IsMin (Classical.choose ⋯) | null | false |
Lean.Parser.Tactic.Doc.tacticAlternativeExt | Lean.Parser.Tactic.Doc | Lean.PersistentEnvExtension (Lean.Name × Lean.Name) (Lean.Name × Lean.Name) (Lean.NameMap Lean.Name) | Stores a collection of *tactic alternatives*, to track which new syntax rules represent new forms of
existing tactics.
| true |
Std.DTreeMap.Internal.Const.RicSliceData.range | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : Type v} → [inst : Ord α] → Std.DTreeMap.Internal.Const.RicSliceData α β → Std.Ric α | null | true |
MeasurableSpace.comap_bot | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {g : β → α}, MeasurableSpace.comap g ⊥ = ⊥ | null | true |
ComplementedLattice.instOrderDual | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [ComplementedLattice α], ComplementedLattice αᵒᵈ | null | true |
DFinsupp.comapDomain'._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_3} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) {h' : ι → κ},
Function.LeftInverse h' h →
∀ (f : Π₀ (i : ι), β i) (s : { s // ∀ (i : ι), i ∈ s ∨ f.toFun i = 0 }) (x : κ),
x ∈ Multiset.map h' ↑s ∨ f (h x) = 0 | null | false |
Equiv.commRing._proof_8 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommRing β] (n : ℤ) (x : α), e (e.symm (n • e x)) = n • e x | null | false |
Std.DHashMap.Raw.toList_toArray | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α],
m.WF → m.toArray.toList = m.toList | null | true |
AlgebraicGeometry.Proj.basicOpenIsoSpec._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_2} {A : Type u_1} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f : A) {m : ℕ},
f ∈ 𝒜 m → 0 < m → CategoryTheory.IsIso (AlgebraicGeometry.Proj.basicOpenToSpec 𝒜 f) | null | false |
SemiRingCat.semiringObj._proof_30 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J SemiRingCat) (j : J),
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Batteries.PairingHeapImp.Heap.WF.rec | Batteries.Data.PairingHeap | ∀ {α : Type u_1} {le : α → α → Bool}
{motive : (a : Batteries.PairingHeapImp.Heap α) → Batteries.PairingHeapImp.Heap.WF le a → Prop},
motive Batteries.PairingHeapImp.Heap.nil ⋯ →
(∀ {a : α} {c : Batteries.PairingHeapImp.Heap α} (h : Batteries.PairingHeapImp.Heap.NodeWF le a c),
motive (Batteries.Pairing... | null | false |
Nat.log_of_lt | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, n < b → Nat.log b n = 0 | null | true |
_private.Mathlib.Analysis.Analytic.IsolatedZeros.0.AnalyticOnNhd.eqOn_or_eventually_ne_of_preconnected._simp_1_1 | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Lean.Constructor.noConfusionType | Lean.Declaration | Sort u → Lean.Constructor → Lean.Constructor → Sort u | null | false |
CommRing.Pic.instAddCommGroupAsModule._proof_1 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) [inst : CommRing R], Small.{u_1, u_1 + 1} (CategoryTheory.Skeleton (SemimoduleCat R))ˣ | null | false |
instPartialOrderEReal._proof_5 | Mathlib.Data.EReal.Basic | ∀ (a : EReal), a ≤ a | null | false |
Matrix.cramer_apply | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α)
(b : n → α) (i : n), A.cramer b i = (A.updateCol i b).det | null | true |
IsUniformAddGroup.cauchy_iff_tendsto_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G] (𝓕 : Filter G),
Cauchy 𝓕 ↔ 𝓕.NeBot ∧ Filter.Tendsto (fun p => p.2 - p.1) (𝓕 ×ˢ 𝓕) (nhds 0) | null | true |
Part.sdiff_get_eq | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : SDiff α] (a b : Part α) (hab : (a \ b).Dom), (a \ b).get hab = a.get ⋯ \ b.get ⋯ | null | true |
IsPurelyInseparable.finSepDegree_eq_one | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [IsPurelyInseparable F E],
Field.finSepDegree F E = 1 | A purely inseparable extension has finite separable degree one. | true |
Float.isNaN | Init.Data.Float | Float → Bool | Checks whether a floating point number is `NaN` (“not a number”) value.
`NaN` values result from operations that might otherwise be errors, such as dividing zero by zero.
This function does not reduce in the kernel. It is compiled to the C operator `isnan`.
| true |
Set.preimage_div_const_Iio | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
(fun x => x / a) ⁻¹' Set.Iio b = Set.Iio (b * a) | null | true |
Std.DTreeMap.Internal.Impl.maxKey?_insert! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insert! k v t).maxKey? =
some (t.maxKey?.elim k fun k' => if (compare k' k).isLE = true then k else k') | null | true |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functor.congr_simp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G G_1 : C} (e_G : G = G_1) [inst_1 : CategoryTheory.Abelian C]
(hG : CategoryTheory.IsSeparator G) {X : C} [inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C]
(A₀ A₀_1 : CategoryTheory.Subobject X),
A₀ = A₀_1 →
∀ (J : Type w) [inst_3 : LinearOr... | null | true |
Lean.Lsp.instToJsonCodeActionLiteralSupportValueSet.toJson | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeActionLiteralSupportValueSet → Lean.Json | null | true |
SimpleGraph.Walk.length | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Walk u v → ℕ | The length of a walk is the number of edges/darts along it. | true |
selfAdjoint.instMulSubtypeMemAddSubgroup._proof_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalCommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), IsSelfAdjoint (↑x * ↑y) | null | false |
Lean.MonadStateCacheT.instMonadFinally._aux_1 | Lean.Util.MonadCache | {α β : Type} →
{m : Type → Type} →
[inst : BEq α] →
[inst_1 : Hashable α] →
[Monad m] →
[MonadFinally m] →
{α_1 β_1 : Type} →
Lean.MonadStateCacheT α β m α_1 →
(Option α_1 → Lean.MonadStateCacheT α β m β_1) → Lean.MonadStateCacheT α β m (α_1 × β_1) | null | false |
MeasureTheory.Measure.IsAddHaarMeasure.toIsFiniteMeasureOnCompacts | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} {inst : AddGroup G} {inst_1 : TopologicalSpace G} {inst_2 : MeasurableSpace G}
{μ : MeasureTheory.Measure G} [self : μ.IsAddHaarMeasure], MeasureTheory.IsFiniteMeasureOnCompacts μ | null | true |
Lean.Meta.Grind.AC.ProofM.State.recOn | Lean.Meta.Tactic.Grind.AC.Proof | {motive : Lean.Meta.Grind.AC.ProofM.State → Sort u} →
(t : Lean.Meta.Grind.AC.ProofM.State) →
((cache : Std.HashMap UInt64 Lean.Expr) →
(varDecls : Std.HashMap Lean.Grind.AC.Var Lean.Expr) →
(exprDecls : Std.HashMap Lean.Grind.AC.Expr Lean.Expr) →
(seqDecls : Std.HashMap Lean.Grind.A... | null | false |
_private.Lean.Syntax.0.Lean.Syntax.asNode._proof_1 | Lean.Syntax | Lean.IsNode (Lean.Syntax.node Lean.SourceInfo.none Lean.nullKind #[]) | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.sum_Iic_sub._proof_1_13 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} (a : Fin n), ↑a + 1 ≤ n → ↑a + 1 < n + 1 | null | false |
_private.Batteries.Linter.UnnecessarySeqFocus.0.Batteries.Linter.UnnecessarySeqFocus.unnecessarySeqFocusLinter.match_3 | Batteries.Linter.UnnecessarySeqFocus | (motive : Lean.Syntax.Range × Lean.Syntax → Sort u_1) →
(x : Lean.Syntax.Range × Lean.Syntax) → ((r : Lean.Syntax.Range) → (stx : Lean.Syntax) → motive (r, stx)) → motive x | null | false |
Polynomial.Splits.zero._simp_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R], Polynomial.Splits 0 = True | null | false |
Std.ExtDHashMap.get!_inter_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} [inst_1 : Inhabited (β k)], k ∉ m₁ → (m₁ ∩ m₂).get! k = default | null | true |
MulOpposite.isCancelMulZero_iff._simp_1 | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α], IsCancelMulZero αᵐᵒᵖ = IsCancelMulZero α | null | false |
Nat.dfold_add._proof_8 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i < n + m, i ≤ n + m | null | false |
AddGroupSeminorm.toOne._proof_3 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] [inst_1 : DecidableEq E] (x : E),
(if -x = 0 then 0 else 1) = if x = 0 then 0 else 1 | null | false |
CategoryTheory.Abelian.AbelianStruct.mk.sizeOf_spec | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{f : X ⟶ Y} [inst_2 : SizeOf C] (kernelFork : CategoryTheory.Limits.KernelFork f)
(isLimitKernelFork : CategoryTheory.Limits.IsLimit kernelFork)
(cokernelCofork : CategoryTheory.Limits.CokernelCofork f... | null | true |
PrimeMultiset.coeNat_prime | Mathlib.Data.PNat.Factors | ∀ (v : PrimeMultiset), ∀ p ∈ v.toNatMultiset, Nat.Prime p | null | true |
Std.DTreeMap.Raw.getKeyD_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k fallback : α}, k ∉ t₁ → (t₁ ∪ t₂).getKeyD k fallback = t₂.getKeyD k fallback | null | true |
Asymptotics.isTheta_completion_left | Mathlib.Analysis.Asymptotics.Completion | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F] {f : α → E}
{g : α → F} {l : Filter α}, (fun x => ↑(g x)) =Θ[l] f ↔ g =Θ[l] f | null | true |
Vector.back_eq_getElem | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} [inst : NeZero n] {xs : Vector α n}, xs.back = xs[n - 1] | null | true |
Matrix.IsAdjMatrix.zero_or_one._autoParam | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | Lean.Syntax | null | false |
instFieldGaloisField._proof_26 | Mathlib.FieldTheory.Finite.GaloisField | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (n : ℕ) (a b c : GaloisField p n), a * (b + c) = a * b + a * c | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.toList_toArray._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder.0.CStarAlgebra.convexOn_ringInverse._proof_1_5 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder | ∀ {A : Type u_1} [inst : CStarAlgebra A], SeparatelyContinuousMul A | null | false |
Finset.Nontrivial.nsmul._f | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddCancelMonoid α] {s : Finset α},
s.Nontrivial → ∀ (x : ℕ) (f : Nat.below (motive := fun x => x ≠ 0 → (x • s).Nontrivial) x), x ≠ 0 → (x • s).Nontrivial | null | false |
CategoryTheory.Limits.Cofork.ext.congr_simp | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y}
{s t : CategoryTheory.Limits.Cofork f g} (i i_1 : s.pt ≅ t.pt) (e_i : i = i_1)
(w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.Limits.Cofork.ext i w = CategoryTheory.Limits.Cofork.ext i_1 ⋯ | null | true |
le_sdiff_right._simp_1 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], (x ≤ y \ x) = (x = ⊥) | null | false |
CategoryTheory.ObjectProperty.instAbelianFullSubcategoryOfContainsZeroOfIsClosedUnderKernelsOfIsClosedUnderCokernelsOfIsClosedUnderFiniteProducts._proof_3 | Mathlib.CategoryTheory.Abelian.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Abelian C] [P.IsClosedUnderCokernels], CategoryTheory.Limits.HasCokernels P.FullSubcategory | null | false |
MulOpposite.instStarOrderedRing | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : StarRing R] [inst_2 : PartialOrder R] [StarOrderedRing R],
StarOrderedRing Rᵐᵒᵖ | null | true |
CategoryTheory.Functor.FullyFaithful.id._proof_1 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C}
(f : (CategoryTheory.Functor.id C).obj X ⟶ (CategoryTheory.Functor.id C).obj Y),
(CategoryTheory.Functor.id C).map f = f | null | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.gaussianReal_add_gaussianReal_of_indepFun._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {R : Type u_1} [inst : Zero R] (n : R) [h : NeZero n], (n = 0) = False | null | false |
Vector.insertIdx_eraseIdx_of_le | Init.Data.Vector.InsertIdx | ∀ {α : Type u} {a : α} {n i j : ℕ} {xs : Vector α n} (w₁ : i < n) (w₂ : j ≤ n - 1) (h : j ≤ i),
(xs.eraseIdx i w₁).insertIdx j a w₂ = Vector.cast ⋯ ((xs.insertIdx j a ⋯).eraseIdx (i + 1) ⋯) | null | true |
AddHom.inverse._proof_2 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N) (g : N → M) (x y : N),
g (f (g x) + f (g y)) = g (f (g x + g y)) | null | false |
ENat.lift_coe | Mathlib.Data.ENat.Basic | ∀ (n : ℕ), (↑n).lift ⋯ = n | null | true |
Lean.Elab.expandOptNamedPrio | Lean.Elab.Util | Lean.Syntax → Lean.MacroM ℕ | null | true |
_private.Mathlib.Combinatorics.Configuration.0.Configuration.HasLines.card_le._simp_1_3 | Mathlib.Combinatorics.Configuration | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
_private.Lean.Environment.0.Lean.Environment.instTypeNameRealizeConstResult | Lean.Environment | TypeName Lean.Environment.RealizeConstResult✝ | null | true |
_private.Mathlib.Algebra.Order.Floor.Semiring.0.Nat.ceil_intCast._simp_1_2 | Mathlib.Algebra.Order.Floor.Semiring | ∀ {m : ℤ} {n : ℕ}, (m.toNat ≤ n) = (m ≤ ↑n) | null | false |
Denumerable.ofEquiv._proof_1 | Mathlib.Logic.Denumerable | ∀ (α : Type u_2) {β : Type u_1} [inst : Denumerable α] (e : β ≃ α) (n : ℕ),
∃ a ∈ Encodable.decode n, Encodable.encode a = n | null | false |
HomogeneousSubsemiring.mk | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring | {ι : Type u_1} →
{σ : Type u_2} →
{A : Type u_3} →
[inst : AddMonoid ι] →
[inst_1 : Semiring A] →
[inst_2 : SetLike σ A] →
[inst_3 : AddSubmonoidClass σ A] →
{𝒜 : ι → σ} →
[inst_4 : DecidableEq ι] →
[inst_5 : GradedRing 𝒜] →
... | null | true |
ContinuousConstVAdd.toMeasurableConstVAdd | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {M : Type u_7} {α : Type u_8} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α]
[inst_3 : VAdd M α] [ContinuousConstVAdd M α], MeasurableConstVAdd M α | null | true |
Std.Http.CustomStatus.mk.sizeOf_spec | Std.Http.Data.Status | ∀ (code : UInt16) (phrase : String)
(validReasonPhrase :
autoParam (Std.Http.IsValidReasonPhrase phrase) Std.Http.CustomStatus.validReasonPhrase._autoParam)
(validCode : autoParam (100 ≤ code ∧ code ≤ 999) Std.Http.CustomStatus.validCode._autoParam)
(validUnknown : autoParam (¬Std.Http.isKnownStatusCode code ... | null | true |
_private.Qq.Match.0.Qq._aux_Qq_Match___macroRules_Lean_Parser_Term_doMatch_1.match_5 | Qq.Match | (motive : Array (Lean.TSyntax `term) × Lean.TSyntax `Lean.Parser.Term.doSeq → Sort u_1) →
(x : Array (Lean.TSyntax `term) × Lean.TSyntax `Lean.Parser.Term.doSeq) →
((patss : Array (Lean.TSyntax `term)) → (rhss : Lean.TSyntax `Lean.Parser.Term.doSeq) → motive (patss, rhss)) →
motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.