name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
IO.Error.illegalOperation.sizeOf_spec | Init.System.IOError | ∀ (osCode : UInt32) (details : String),
sizeOf (IO.Error.illegalOperation osCode details) = 1 + sizeOf osCode + sizeOf details | true |
ENNReal.div_eq_div_iff | Mathlib.Data.ENNReal.Inv | ∀ {a b c d : ENNReal}, a ≠ 0 → a ≠ ⊤ → b ≠ 0 → b ≠ ⊤ → (c / b = d / a ↔ a * c = b * d) | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.TFAE_mem_nhdsGE.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (s : Set α) (motive : (∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s) → Prop)
(x : ∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s),
(∀ (u : α) (umem : u ∈ Set.Ioc a b) (hu : Set.Ico a u ⊆ s), motive ⋯) → motive x | false |
CategoryTheory.ObjectProperty.instIsTriangulatedMinOfIsClosedUnderIsomorphisms | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P P' : Catego... | true |
CauSeq.Completion.Cauchy.ring._proof_32 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x x_1 : CauSeq β abv),
CauSeq.Completion.mk (x + x_1) = CauSeq.Completion.mk x + CauSeq.Completion.mk x_1 | false |
FourierPair.fourierInv_fourier_eq | Mathlib.Analysis.Fourier.Notation | ∀ {E : Type u_5} {F : Type u_6} {inst : FourierTransform E F} {inst_1 : FourierTransformInv F E}
[self : FourierPair E F] (f : E), FourierTransformInv.fourierInv (FourierTransform.fourier f) = f | true |
Complex.log_zero | Mathlib.Analysis.SpecialFunctions.Complex.Log | Complex.log 0 = 0 | true |
CategoryTheory.Functor.rightDerived_fac_assoc | Mathlib.CategoryTheory.Functor.Derived.RightDerived | ∀ {C : Type u_3} {D : Type u_1} {H : Type u_2} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Category.{v_3, u_1} D] [inst_2 : CategoryTheory.Category.{v_5, u_2} H]
(RF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : F ⟶ L.comp RF) (W : ... | true |
PadicInt.instIsDiscreteValuationRing | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], IsDiscreteValuationRing ℤ_[p] | true |
DivInvMonoid.mk | Mathlib.Algebra.Group.Defs | {G : Type u} →
[toMonoid : Monoid G] →
[toInv : Inv G] →
[toDiv : Div G] →
autoParam (∀ (a b : G), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam →
(zpow : ℤ → G → G) →
autoParam (∀ (a : G), zpow 0 a = 1) DivInvMonoid.zpow_zero'._autoParam →
autoParam (∀ ... | true |
CategoryTheory.PreservesImage.hom_comp_map_image_ι | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Images | ∀ {A : Type u₁} {B : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Limits.HasEqualizers A] [inst_3 : CategoryTheory.Limits.HasImages A]
[inst_4 : CategoryTheory.StrongEpiCategory B] [inst_5 : CategoryTheory.Limits.HasImages B]
(L : Cate... | true |
Lean.Meta.ExtractLets.LocalDecl'.noConfusion | Lean.Meta.Tactic.Lets | {P : Sort u} →
{t t' : Lean.Meta.ExtractLets.LocalDecl'} → t = t' → Lean.Meta.ExtractLets.LocalDecl'.noConfusionType P t t' | false |
Std.ExtTreeMap.getElem?_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a b : α},
cmp a b = Ordering.eq → t[a]? = t[b]? | true |
Sym.eq_nil_of_card_zero | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} (s : Sym α 0), s = Sym.nil | true |
_private.Mathlib.Analysis.InnerProductSpace.MeanErgodic.0.«_aux_Mathlib_Analysis_InnerProductSpace_MeanErgodic___macroRules__private_Mathlib_Analysis_InnerProductSpace_MeanErgodic_0_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.MeanErgodic | Lean.Macro | false |
Lean.KeyedDeclsAttribute.OLeanEntry._sizeOf_1 | Lean.KeyedDeclsAttribute | Lean.KeyedDeclsAttribute.OLeanEntry → ℕ | false |
Std.TreeMap.Raw.getEntryGED | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → α × β → α × β | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.sup_pure._simp_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} (a : α), pure a = Filter.principal {a} | false |
CategoryTheory.Preadditive.mk.noConfusion | Mathlib.CategoryTheory.Preadditive.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{P : Sort u_1} →
{homGroup : autoParam ((P Q : C) → AddCommGroup (P ⟶ Q)) CategoryTheory.Preadditive.homGroup._autoParam} →
{add_comp :
autoParam
(∀ (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
CategoryTh... | false |
CategoryTheory.Limits.IsLimit.binaryFanSwap | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{s : CategoryTheory.Limits.BinaryFan X Y} → CategoryTheory.Limits.IsLimit s → CategoryTheory.Limits.IsLimit s.swap | true |
AffineMap.ofMapMidpoint._proof_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {V : Type u_2} {P : Type u_4} {W : Type u_1} {Q : Type u_3} [inst : SeminormedAddCommGroup V]
[inst_1 : PseudoMetricSpace P] [inst_2 : NormedAddTorsor V P] [inst_3 : NormedAddCommGroup W] [inst_4 : MetricSpace Q]
[inst_5 : NormedAddTorsor W Q] [inst_6 : NormedSpace ℝ V] [inst_7 : NormedSpace ℝ W] (f : P → Q),
(... | false |
CategoryTheory.Bicategory.Adjunction.homEquiv₂.eq_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c},
adj.homEquiv₂ =
{
toFun := fun α =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).inv
(Category... | true |
CategoryTheory.yonedaEquiv_symm_naturality_right | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) {F F' : CategoryTheory.Functor Cᵒᵖ (Type v₁)}
(f : F ⟶ F') (x : F.obj (Opposite.op X)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.yonedaEquiv.symm x) f =
CategoryTheory.yonedaEquiv.symm (f.app (Opposite.op X) x) | true |
Nat.prod_primeFactorsList | Mathlib.Data.Nat.Factors | ∀ {n : ℕ}, n ≠ 0 → n.primeFactorsList.prod = n | true |
_private.Lean.Elab.Tactic.NormCast.0.Lean.Elab.Tactic.NormCast.splittingProcedure.match_14 | Lean.Elab.Tactic.NormCast | (motive : Lean.Expr → Sort u_1) →
(expr : Lean.Expr) → ((op x y : Lean.Expr) → motive ((op.app x).app y)) → ((x : Lean.Expr) → motive x) → motive expr | false |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {n : ℕ} (hn : autoParam ((SimplexCategory.mk n).len ≤ 2) SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_1)
(hn' : autoParam ((SimplexCategory.mk (n + 1)).len ≤ 2) SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_3),
CategoryTheory.CategoryStruct.comp (SimplexCategory.Truncated.δ₂ 1 hn hn') (SimplexCategor... | true |
instContinuousAddULift | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M], ContinuousAdd (ULift.{u, u_3} M) | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.unit | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} → {β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → Std.Sat.Literal α → β | true |
CochainComplex.shiftFunctorZero_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : CochainComplex C ℤ) (n : ℤ),
((CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n = (HomologicalComplex.XIsoOfEq K ⋯).hom | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.extract'._simp_1_7 | Batteries.Data.String.Lemmas | ∀ {m k n : ℕ}, (n + m ≤ n + k) = (m ≤ k) | false |
Std.Iter.find?_eq_findSome? | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} [inst : Std.Iterator α Id β] [inst_1 : Std.IteratorLoop α Id Id] [Std.Iterators.Finite α Id]
{it : Std.Iter β} {f : β → Bool}, it.find? f = it.findSome? fun x => if f x = true then some x else none | true |
Lean.Elab.Info.ofChoiceInfo.injEq | Lean.Elab.InfoTree.Types | ∀ (i i_1 : Lean.Elab.ChoiceInfo), (Lean.Elab.Info.ofChoiceInfo i = Lean.Elab.Info.ofChoiceInfo i_1) = (i = i_1) | true |
Equiv.nonUnitalCommSemiring._proof_2 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β] (x y : α),
e (e.symm (e x + e y)) = e x + e y | false |
Lean.Omega.Constraint.not_sat_of_isImpossible | Init.Omega.Constraint | ∀ {c : Lean.Omega.Constraint}, c.isImpossible = true → ∀ {t : ℤ}, ¬c.sat t = true | true |
CategoryTheory.IsVanKampenColimit | Mathlib.CategoryTheory.Limits.VanKampen | {J : Type v'} →
[inst : CategoryTheory.Category.{u', v'} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor J C} → CategoryTheory.Limits.Cocone F → Prop | true |
Matrix.reindex_isTotallyUnimodular | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular | ∀ {m : Type u_1} {m' : Type u_2} {n : Type u_3} {n' : Type u_4} {R : Type u_5} [inst : CommRing R] (A : Matrix m n R)
(em : m ≃ m') (en : n ≃ n'), ((Matrix.reindex em en) A).IsTotallyUnimodular ↔ A.IsTotallyUnimodular | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic.0.CFC.posPart_negPart_unique._simp_1_4 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {inst : Star R} {inst_1 : Star S}
{inst_2 : FunLike F R S} [self : StarHomClass F R S] (f : F) (r : R), star (f r) = f (star r) | false |
IsLocallyInjective_iff_isOpenEmbedding | Mathlib.Topology.SeparatedMap | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y},
IsLocallyInjective f ↔ Topology.IsOpenEmbedding (toPullbackDiag f) | true |
Lean.IR.Checker.CheckerContext.mk.sizeOf_spec | Lean.Compiler.IR.Checker | ∀ (localCtx : Lean.IR.LocalContext) (currentDecl : Lean.IR.Decl) (decls : Array Lean.IR.Decl),
sizeOf { localCtx := localCtx, currentDecl := currentDecl, decls := decls } =
1 + sizeOf localCtx + sizeOf currentDecl + sizeOf decls | true |
instInhabitedCompactum._aux_1 | Mathlib.Topology.Category.Compactum | Compactum | false |
Profinite.NobelingProof.Products.lt_ord_of_lt | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u} [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {l m : Profinite.NobelingProof.Products I}
{o : Ordinal.{u}},
m < l → (∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o) → ∀ i ∈ ↑m, Profinite.NobelingProof.ord I i < o | true |
FunctionField.FqtInfty.instField._aux_48 | Mathlib.NumberTheory.FunctionField | (Fq : Type u_1) →
[inst : Field Fq] → [inst_1 : DecidableEq (RatFunc Fq)] → FunctionField.FqtInfty Fq → FunctionField.FqtInfty Fq | false |
Std.TreeMap.get_union_of_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
(mem : k ∈ t₂), (t₁ ∪ t₂).get k ⋯ = t₂.get k mem | true |
_private.Mathlib.Algebra.Group.Submonoid.Units.0.Subgroup.mem_units_iff_val_mem._simp_1_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {S : Type u_3} {G : Type u_4} [inst : InvolutiveInv G] {x : SetLike S G} [InvMemClass S G] {H : S} {x_1 : G},
(x_1⁻¹ ∈ H) = (x_1 ∈ H) | false |
_private.Mathlib.Data.Num.ZNum.0.ZNum.mul_comm | Mathlib.Data.Num.ZNum | ∀ (a b : ZNum), a * b = b * a | true |
Lean.Lsp.ServerInfo._sizeOf_inst | Lean.Data.Lsp.InitShutdown | SizeOf Lean.Lsp.ServerInfo | false |
Function.Bijective.finite_iff | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → (Finite α ↔ Finite β) | true |
IntervalIntegrable.comp_add_left_iff._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax | false |
IsUltrametricDist.ball_openAddSubgroup.eq_1 | Mathlib.Analysis.Normed.Group.Ultra | ∀ (S : Type u_1) [inst : SeminormedAddGroup S] [inst_1 : IsUltrametricDist S] {r : ℝ} (hr : 0 < r),
IsUltrametricDist.ball_openAddSubgroup S hr =
{ carrier := Metric.ball 0 r, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯, isOpen' := ⋯ } | true |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage._proof_1 | Mathlib.CategoryTheory.Limits.Types.Images | ∀ {F : CategoryTheory.Functor ℕᵒᵖ (Type u_1)},
(∀ (n : ℕ), Function.Surjective (F.map (CategoryTheory.homOfLE ⋯).op)) →
∀ (n : ℕ) (x : Nat.below n.succ), ∃ a, F.map (CategoryTheory.homOfLE ⋯).op a = x.1 | false |
_private.Mathlib.Topology.Order.0.IndiscreteTopology.isClosed_iff._simp_1_2 | Mathlib.Topology.Order | ∀ {α : Type u_1} {t₂ : TopologicalSpace α} [IndiscreteTopology α] (U : Set α), IsOpen U = (U = ∅ ∨ U = Set.univ) | false |
Lean.Grind.CommRing.Mon.below | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Mon → Sort u} → Lean.Grind.CommRing.Mon → Sort (max 1 u) | false |
_private.Mathlib.Algebra.Central.End.0.LinearEquiv.conjAlgEquiv_ext_iff._simp_1_2 | Mathlib.Algebra.Central.End | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_8} {M₂ : Type u_9} {M₃ : Type u_10} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ :... | false |
ValuationSubring.algebra | Mathlib.RingTheory.Valuation.AlgebraInstances | {K : Type u_1} →
[inst : Field K] →
(v : Valuation K (WithZero (Multiplicative ℤ))) →
(L : Type u_2) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
(E : Type u_3) →
[inst_3 : Field E] →
[inst_4 : Algebra K E] →
[inst_5 : Algebra ... | true |
WeierstrassCurve.Projective.addXYZ_of_Z_eq_zero_left | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P → P 2 = 0 → W'.addXYZ P Q = (P 1 ^ 2 * Q 2) • Q | true |
MeasureTheory.Measure.restrict_le_self | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, μ.restrict s ≤ μ | true |
Int16.instUpwardEnumerable | Init.Data.Range.Polymorphic.SInt | Std.PRange.UpwardEnumerable Int16 | true |
instReprSymbol.repr | Mathlib.Computability.Language | {T : Type u_4} → {N : Type u_5} → [Repr T] → [Repr N] → Symbol T N → ℕ → Std.Format | true |
Representation.ofDistribMulAction_apply_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {A : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid A]
[inst_3 : Module k A] [inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (g : G) (a : A),
((Representation.ofDistribMulAction k G A) g) a = g • a | true |
Fin.ctorIdx | Init.Prelude | {n : ℕ} → Fin n → ℕ | false |
MeasurableSpace.comap_le_comap_pi | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {β : Type u_2} {δ : Type u_4} {X : δ → Type u_6} [inst : (a : δ) → MeasurableSpace (X a)] {g : (a : δ) → β → X a}
(a : δ), MeasurableSpace.comap (g a) inferInstance ≤ MeasurableSpace.comap (fun b c => g c b) MeasurableSpace.pi | true |
Equiv.addLeft | Mathlib.Algebra.Group.Units.Equiv | {G : Type u_5} → [AddGroup G] → G → Equiv.Perm G | true |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.degree_mod_lt._simp_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic = (p.leadingCoeff = 1) | false |
Polynomial.lsum._proof_2 | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Semiring A] [inst_2 : AddCommMonoid M]
[inst_3 : Module R A] [inst_4 : Module R M] (f : ℕ → A →ₗ[R] M) (p q : Polynomial A),
((p + q).sum fun x1 x2 => (f x1) x2) = (p.sum fun x1 x2 => (f x1) x2) + q.sum fun x1 x2 => (f x1) x2 | false |
Lean.Omega.Constraint.addInequality_sat | Init.Omega.Constraint | ∀ {c : ℤ} {x y : Lean.Omega.Coeffs}, c + x.dot y ≥ 0 → { lowerBound := some (-c), upperBound := none }.sat' x y = true | true |
_private.Mathlib.MeasureTheory.OuterMeasure.Caratheodory.0.MeasureTheory.OuterMeasure.top_caratheodory._simp_1_1 | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | false |
Frm.instCategory._proof_3 | Mathlib.Order.Category.Frm | ∀ {W X Y Z : Frm} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } | false |
Turing.PartrecToTM2.K'.elim.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a b c d : List Turing.PartrecToTM2.Γ'), Turing.PartrecToTM2.K'.elim a b c d Turing.PartrecToTM2.K'.rev = b | true |
Order.IsPredLimit.dual | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α], Order.IsPredLimit a → Order.IsSuccLimit (OrderDual.toDual a) | true |
List.«_aux_Init_Data_List_Basic___macroRules_List_term_<+__1» | Init.Data.List.Basic | Lean.Macro | false |
Multiset.exists_max_image | Mathlib.Data.Finset.Max | ∀ {α : Type u_7} {R : Type u_8} [inst : LinearOrder R] (f : α → R) {s : Multiset α}, s ≠ 0 → ∃ y ∈ s, ∀ z ∈ s, f z ≤ f y | true |
WeierstrassCurve.Affine.CoordinateRing.basis | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} →
[inst : CommRing R] → (W' : WeierstrassCurve.Affine R) → Module.Basis (Fin 2) (Polynomial R) W'.CoordinateRing | true |
LinOrd._sizeOf_inst | Mathlib.Order.Defs.LinearOrder | SizeOf LinOrd | false |
Option.mem_filter_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {a : α} {o : Option α}, a ∈ Option.filter p o ↔ a ∈ o ∧ p a = true | true |
NumberField.RingOfIntegers.instSMulDistribClass | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] {G : Type u_3} [inst_1 : Group G] [inst_2 : MulSemiringAction G K],
SMulDistribClass G (NumberField.RingOfIntegers K) K | true |
Lean.Meta.Grind.Methods.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ (propagateUp propagateDown : Lean.Meta.Grind.Propagator) (evalTactic : Lean.Meta.Grind.EvalTactic),
sizeOf { propagateUp := propagateUp, propagateDown := propagateDown, evalTactic := evalTactic } = 1 | true |
Lean.Meta.Origin.other.sizeOf_spec | Lean.Meta.Tactic.Simp.SimpTheorems | ∀ (name : Lean.Name), sizeOf (Lean.Meta.Origin.other name) = 1 + sizeOf name | true |
iteratedDeriv_const_smul | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {R : Type u_3} [inst_3 : DistribSMul R F] [SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F] {n : ℕ} {f : 𝕜 → F},
ContDiffAt 𝕜 (↑n) f x → ∀ (c : R), iteratedDeriv n (c • f) x =... | true |
isAddRightRegular_toDual | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : α}, IsAddRightRegular (OrderDual.toDual a) ↔ IsAddRightRegular a | true |
_private.Lean.Meta.Tactic.Grind.AC.PP.0.Lean.Meta.Grind.AC.instMonadGetStructM | Lean.Meta.Tactic.Grind.AC.PP | Lean.Meta.Grind.AC.MonadGetStruct Lean.Meta.Grind.AC.M✝ | true |
Filter.eventually_all_finset | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Type u_2} (I : Finset ι) {l : Filter α} {p : ι → α → Prop},
(∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.append.match_1.eq_5 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (motive : Batteries.RBNode α → Batteries.RBNode α → Sort u_2) (l : Batteries.RBNode α) (v : α)
(r b : Batteries.RBNode α) (x : α) (c : Batteries.RBNode α)
(h_1 : (x : Batteries.RBNode α) → motive Batteries.RBNode.nil x)
(h_2 : (x : Batteries.RBNode α) → motive x Batteries.RBNode.nil)
(h_3 :
... | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Piecewise.0.Finset.prod_dite_of_true._proof_1_6 | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {s : Finset ι} {p : ι → Prop}, (∀ i ∈ s, p i) → ∀ a ∈ s, p a | false |
LinearMap.addCommGroup._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₂ : Type u_1} {N₂ : Type u_2} [inst : Semiring R₂] [inst_1 : AddCommGroup N₂] [inst_2 : Module R₂ N₂],
SMulCommClass R₂ ℤ N₂ | false |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.toACExpr.toPreExpr | Lean.Meta.Tactic.AC.Main | Lean.Expr → Lean.Expr → StateT Lean.ExprSet Lean.MetaM Lean.Meta.AC.PreExpr | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.succ_mem_succ_succ_iff._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LinearlyUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.Rxo.IsAlwaysFinite α] [Std.PRange.LawfulUpwardEnumerable α]
{lo hi a : α}, (a ∈ (Std.PRange.... | false |
Unitization.instSemiring | Mathlib.Algebra.Algebra.Unitization | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] → [IsScalarTower R A A] → [SMulCommClass R A A] → Semiring (Unitization R A) | true |
Batteries.PairingHeapImp.instDecidableNoSibling | Batteries.Data.PairingHeap | {α : Type u_1} → {s : Batteries.PairingHeapImp.Heap α} → Decidable s.NoSibling | true |
AddSubgroupClass.coe_zmod_smul | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G]
{K : S} [inst_3 : Module (ZMod n) G] (a : ZMod n) (x : ↥K), ↑(a • x) = a • ↑x | true |
Std.Tactic.BVDecide.LRAT.Internal.Entails.eval | Std.Tactic.BVDecide.LRAT.Internal.Entails | {α : Type u} → {β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Entails α β] → (α → Bool) → β → Prop | true |
Geometry.SimplicialComplex.ofSubcomplex_faces | Mathlib.Analysis.Convex.SimplicialComplex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (K : Geometry.SimplicialComplex 𝕜 E) (faces : Set (Finset E)) (subset : faces ⊆ K.faces)
(down_closed : IsLowerSet faces), (K.ofSubcomplex faces subset down_closed).faces = faces | true |
Lean.Server.Test.Runner.Client.normalizedRef | Lean.Server.Test.Runner | Lean.Lsp.RpcRef → Lean.Server.Test.Runner.Client.NormalizeM Lean.Lsp.RpcRef | true |
SetRel.rightDual_mem_leftFixedPoint | Mathlib.Order.Rel.GaloisConnection | ∀ {α : Type u_1} {β : Type u_2} (R : SetRel α β) (I : Set β), R.rightDual I ∈ R.leftFixedPoints | true |
ProofWidgets.GetExprPresentationParams.rec | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.GetExprPresentationParams → Sort u} →
((expr : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx) →
(name : Lean.Name) → motive { expr := expr, name := name }) →
(t : ProofWidgets.GetExprPresentationParams) → motive t | false |
String.instLEPos_1 | Init.Data.String.Defs | {s : String.Slice} → LE s.Pos | true |
Turing.PartrecToTM2.copy_ok | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (q : Turing.PartrecToTM2.Λ') (s : Option Turing.PartrecToTM2.Γ') (a b c d : List Turing.PartrecToTM2.Γ'),
StateTransition.Reaches₁ (Turing.TM2.step Turing.PartrecToTM2.tr)
{ l := some q.copy, var := s, stk := Turing.PartrecToTM2.K'.elim a b c d }
{ l := some q, var := none, stk := Turing.PartrecToTM2.K'.eli... | true |
hfdifferential._proof_10 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_6} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_5}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_2} [inst_6 : NormedAddComm... | false |
ProbabilityTheory.Kernel.IsProper.setLIntegral_eq_indicator_mul_lintegral | Mathlib.Probability.Kernel.Proper | ∀ {X : Type u_1} {𝓑 𝓧 : MeasurableSpace X} {π : ProbabilityTheory.Kernel X X} {B : Set X} {f : X → ENNReal},
π.IsProper →
𝓑 ≤ 𝓧 →
Measurable f → MeasurableSet B → ∀ (x₀ : X), ∫⁻ (x : X) in B, f x ∂π x₀ = B.indicator 1 x₀ * ∫⁻ (x : X), f x ∂π x₀ | true |
Std.TreeMap.minKey_modify_eq_minKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {f : β → β} {he : (t.modify k f).isEmpty = false}, (t.modify k f).minKey he = t.minKey ⋯ | true |
BddLat.hom_comp | Mathlib.Order.Category.BddLat | ∀ {X Y Z : Lat} (f : X ⟶ Y) (g : Y ⟶ Z),
Lat.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (Lat.Hom.hom g).comp (Lat.Hom.hom f) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.