name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DHashMap.Const.get_union_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁.union m₂},
Std.DHashMap.Const.get (m₁.union m₂) k h' = Std.DHashMap.Const.get m₂ k ⋯ | true |
Fin.succFunctor_map | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (n : ℕ) {x x_1 : Fin n} (hij : x ⟶ x_1), (Fin.succFunctor n).map hij = CategoryTheory.homOfLE ⋯ | true |
ContinuousAt.mabs | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : LinearOrder G] [IsOrderedMonoid G]
[OrderTopology G] {X : Type u_2} [inst_5 : TopologicalSpace X] {f : X → G} {x : X},
ContinuousAt f x → ContinuousAt (fun x => |f x|ₘ) x | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.totallyBounded_interUnionBalls._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | false |
PrimeSpectrum.primeSpectrumProd._proof_2 | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S],
Function.Bijective (PrimeSpectrum.primeSpectrumProdOfSum R S) | false |
Set.prod_quotient_preimage_eq_image | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} [s : Setoid α] (g : Quotient s → β) {h : α → β},
h = g ∘ Quotient.mk'' →
∀ (r : Set (β × β)), {x | (g x.1, g x.2) ∈ r} = (fun a => (⟦a.1⟧, ⟦a.2⟧)) '' ((fun a => (h a.1, h a.2)) ⁻¹' r) | true |
Lean.IR.Param.mk.inj | Lean.Compiler.IR.Basic | ∀ {x : Lean.IR.VarId} {borrow : Bool} {ty : Lean.IR.IRType} {x_1 : Lean.IR.VarId} {borrow_1 : Bool}
{ty_1 : Lean.IR.IRType},
{ x := x, borrow := borrow, ty := ty } = { x := x_1, borrow := borrow_1, ty := ty_1 } →
x = x_1 ∧ borrow = borrow_1 ∧ ty = ty_1 | true |
NNReal.summable_rpow_inv | Mathlib.Analysis.PSeries | ∀ {p : ℝ}, (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p | true |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.inferAppType.match_1 | Lean.Compiler.LCNF.InferType | (motive : (pu : Lean.Compiler.LCNF.Purity) → Array (Lean.Compiler.LCNF.Arg pu) → Sort u_1) →
(pu : Lean.Compiler.LCNF.Purity) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
((args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive Lean.Compiler.LCNF.Purity.pure args) →
((args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure)) →
motive Lean.Compiler.LCNF.Purity.impure args) →
motive pu args | false |
Bool.rec.eq._@.Mathlib.Util.CompileInductive.3618634379._hygCtx._hyg.4 | Mathlib.Util.CompileInductive | @Bool.rec = @Bool.rec✝ | false |
Lean.Parser.Command.init_quot.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | true |
List.rotate_append_length_eq | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l l' : List α), (l ++ l').rotate l.length = l' ++ l | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.PendingField.rec | Lean.Elab.StructInst | {motive : Lean.Elab.Term.StructInst.PendingField✝ → Sort u} →
((fieldName : Lean.Name) →
(fieldType : Lean.Expr) →
(required : Bool) →
(deps : Lean.NameSet) →
(val? : Option Lean.Expr) →
motive
{ fieldName := fieldName, fieldType := fieldType, required := required, deps := deps, val? := val? }) →
(t : Lean.Elab.Term.StructInst.PendingField✝¹) → motive t | false |
AddCon.kerLift_injective | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : AddZeroClass M] [inst_1 : AddZeroClass P] (f : M →+ P),
Function.Injective ⇑(AddCon.kerLift f) | true |
CategoryTheory.Discrete.monoidal._proof_13 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u_1) [inst : Monoid M] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : CategoryTheory.Discrete M} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
(f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (CategoryTheory.Discrete.eqToIso ⋯).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Discrete.eqToIso ⋯).hom (CategoryTheory.eqToHom ⋯) | false |
TensorProduct.ite_tmul | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (x₁ : M) (x₂ : N) (P : Prop)
[inst_5 : Decidable P], (if P then x₁ else 0) ⊗ₜ[R] x₂ = if P then x₁ ⊗ₜ[R] x₂ else 0 | true |
Odd | Mathlib.Algebra.Ring.Parity | {α : Type u_2} → [Semiring α] → α → Prop | true |
RingQuot._sizeOf_inst | Mathlib.Algebra.RingQuot | {R : Type uR} →
{inst : Semiring R} → (r : R → R → Prop) → [SizeOf R] → [(a a_1 : R) → SizeOf (r a a_1)] → SizeOf (RingQuot r) | false |
Std.Net.InterfaceAddress | Std.Net.Addr | Type | true |
Real.sqrtTwoAddSeries.eq_def | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (x_1 : ℕ),
x.sqrtTwoAddSeries x_1 =
match x_1 with
| 0 => x
| n.succ => √(2 + x.sqrtTwoAddSeries n) | true |
StrictMonoOn.monotoneOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictMonoOn f s → MonotoneOn f s | true |
CategoryTheory.Functor.IsCoverDense.Types.presheafIso.congr_simp | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} [inst_2 : G.IsCoverDense K] [inst_3 : G.IsLocallyFull K]
{ℱ ℱ' : CategoryTheory.Sheaf K (Type v)} (i i_1 : G.op.comp ℱ.obj ≅ G.op.comp ℱ'.obj),
i = i_1 →
CategoryTheory.Functor.IsCoverDense.Types.presheafIso i = CategoryTheory.Functor.IsCoverDense.Types.presheafIso i_1 | true |
CategoryTheory.MorphismProperty.Comma.Hom.comp._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_2, u_5} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_3, u_6} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory.MorphismProperty A} {W : CategoryTheory.MorphismProperty B} [Q.IsStableUnderComposition]
{X Y Z : CategoryTheory.MorphismProperty.Comma L R P Q W} (f : X.Hom Y) (g : Y.Hom Z),
Q (CategoryTheory.CategoryStruct.comp f.left g.left) | false |
Finset.image_neg | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq β] [inst_2 : AddGroup α]
[inst_3 : SubtractionMonoid β] [inst_4 : FunLike F α β] [AddMonoidHomClass F α β] (f : F) (s : Finset α),
Finset.image (⇑f) (-s) = -Finset.image (⇑f) s | true |
MaximalSpectrum.mapPiLocalization.congr_simp | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f f_1 : R →+* S) (e_f : f = f_1)
(hf : Function.Bijective ⇑f), MaximalSpectrum.mapPiLocalization f hf = MaximalSpectrum.mapPiLocalization f_1 ⋯ | true |
_private.Mathlib.RingTheory.Extension.Presentation.Core.0.Algebra.SubmersivePresentation.ofHasCoeffs._simp_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
Int8.and_assoc | Init.Data.SInt.Bitwise | ∀ (a b c : Int8), a &&& b &&& c = a &&& (b &&& c) | true |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass_add | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y) {n : ℕ}
(x y : CategoryTheory.Abelian.Ext X Y n),
R.extEquivCohomologyClass (x + y) = R.extEquivCohomologyClass x + R.extEquivCohomologyClass y | true |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical.mkNot | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical | Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical →
Lean.Expr → Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.M Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical | true |
_private.Lean.Meta.Tactic.FunIndCollect.0.Lean.Meta.FunInd.collect.unsafe_1 | Lean.Meta.Tactic.FunIndCollect | Lean.Meta.FunIndInfo → Lean.MVarId → Lean.MetaM (Array Lean.Expr) | true |
MulAlgebraNorm.ext_iff | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : outParam (Type u_1)} {S : outParam (Type u_2)} [inst : SeminormedCommRing R] [inst_1 : Ring S]
[inst_2 : Algebra R S] {p q : MulAlgebraNorm R S}, p = q ↔ ∀ (x : S), p x = q x | true |
addCommutator_eq_closure | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : AddGroup G], addCommutator G = AddSubgroup.closure (addCommutatorSet G) | true |
SubalgebraClass.seminormedRing._proof_15 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {S : Type u_2} {E : Type u_1} [inst : SeminormedRing E] [inst_1 : SetLike S E] [inst_2 : SubringClass S E] (s : S)
(a : ↥s), SubNegMonoid.zsmul 0 a = 0 | false |
SimpleGraph.edgeDensity.eq_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_4} (G : SimpleGraph α) [inst : DecidableRel G.Adj], G.edgeDensity = Rel.edgeDensity G.Adj | true |
Homeomorph.piCongrLeft_symm_apply | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_7} {ι' : Type u_8} {Y : ι' → Type u_9} [inst : (j : ι') → TopologicalSpace (Y j)] (e : ι ≃ ι'),
⇑(Homeomorph.piCongrLeft e).symm = fun x1 x2 => x1 (e x2) | true |
Lean.JsonRpc.RequestID.num.sizeOf_spec | Lean.Data.JsonRpc | ∀ (n : Lean.JsonNumber), sizeOf (Lean.JsonRpc.RequestID.num n) = 1 + sizeOf n | true |
CategoryTheory.Limits.hasStrongEpiImages_of_hasStrongEpiMonoFactorisations | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C], CategoryTheory.Limits.HasStrongEpiImages C | true |
Polynomial.instCommRingUniversalFactorizationRing._proof_45 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
autoParam (∀ (n_1 : ℕ), IntCast.intCast ↑n_1 = ↑n_1) AddGroupWithOne.intCast_ofNat._autoParam | false |
Fintype.expect_ite_zero | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {M : Type u_3} [inst : Fintype ι] [inst_1 : AddCommMonoid M] [inst_2 : Module ℚ≥0 M] (p : ι → Prop)
[inst_3 : DecidablePred p],
(∀ (i j : ι), p i → p j → i = j) →
∀ (a : M), (Finset.univ.expect fun i => if p i then a else 0) = if ∃ i, p i then (↑(Fintype.card ι))⁻¹ • a else 0 | true |
RightCosetEquivalence | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [Mul α] → Set α → α → α → Prop | true |
ENNReal.inv_eq_zero | Mathlib.Data.ENNReal.Inv | ∀ {a : ENNReal}, a⁻¹ = 0 ↔ a = ⊤ | true |
MagmaCat.instCategory._proof_3 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {W X Y Z : MagmaCat} (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 |
Lean.Elab.WF.GuessLex.RecCallCache.mk'' | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Name →
Option Lean.Elab.DecreasingBy →
Array Lean.Elab.WF.GuessLex.BasicMeasure →
Array Lean.Elab.WF.GuessLex.BasicMeasure →
Lean.Elab.WF.GuessLex.RecCallWithContext →
IO.Ref (Array (Array (Option Lean.Elab.WF.GuessLex.GuessLexRel))) → Lean.Elab.WF.GuessLex.RecCallCache | true |
Lean.Meta.mkLetValCongr | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
CategoryTheory.Lax.OplaxTrans.LaxFunctor.bicategory._proof_10 | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_6) [inst_1 : CategoryTheory.Bicategory C]
{a b c : CategoryTheory.LaxFunctor B C} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.Lax.OplaxTrans.whiskerRight (CategoryTheory.CategoryStruct.id f) g =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g) | false |
Set.surjOn_of_subsingleton | Mathlib.Data.Set.Function | ∀ {α : Type u_1} [Subsingleton α] (f : α → α) (s : Set α), Set.SurjOn f s s | true |
not_forall_of_exists_not | Init.PropLemmas | ∀ {α : Sort u_1} {p : α → Prop}, (∃ x, ¬p x) → ¬∀ (x : α), p x | true |
IntermediateField.essFiniteType_iff | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {K : IntermediateField F E},
Algebra.EssFiniteType F ↥K ↔ K.FG | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.instSubsingletonUniformOnFun._proof_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_2} {β : Type u_1} {𝔖 : Set (Set α)} [Subsingleton β], Subsingleton (UniformOnFun α β 𝔖) | false |
Nat.bitIndices_two_pow_mul | Mathlib.Data.Nat.BitIndices | ∀ (k n : ℕ), (2 ^ k * n).bitIndices = List.map (fun x => x + k) n.bitIndices | true |
birkhoffSum_one' | Mathlib.Dynamics.BirkhoffSum.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (f : α → α) (g : α → M), birkhoffSum f g 1 = g | true |
Lean.ExtraModUse.casesOn | Lean.ExtraModUses | {motive : Lean.ExtraModUse → Sort u} →
(t : Lean.ExtraModUse) →
((module : Lean.Name) →
(isExported isMeta : Bool) → motive { module := module, isExported := isExported, isMeta := isMeta }) →
motive t | false |
Bicategory.Opposite.Hom2.unop2 | Mathlib.CategoryTheory.Bicategory.Opposites | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → {a b : Bᵒᵖ} → {f g : a ⟶ b} → Bicategory.Opposite.Hom2 f g → (f.unop ⟶ g.unop) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.0.SimpleGraph.eq_top_of_chromaticNumber_eq_card._proof_1_4 | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u_1} {G : SimpleGraph V} [inst : Fintype V] (a b : V) (hne : a ≠ b),
¬G.Adj a b →
∀ {v w : V}, G.Adj v w → ¬(if h' : ¬v = b then ⟨v, ⋯⟩ else ⟨a, ⋯⟩) = if h' : ¬w = b then ⟨w, ⋯⟩ else ⟨a, ⋯⟩ | false |
Std.TreeMap.Raw.compare_getKey_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} (h' : k ∈ t), cmp (t.getKey k h') k = Ordering.eq | true |
ContinuousMap.instCommRingOfIsTopologicalRing._proof_2 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : CommRing β] [IsTopologicalRing β], ContinuousMul β | false |
MeasureTheory.SimpleFunc.approxOn | Mathlib.MeasureTheory.Function.SimpleFuncDense | {α : Type u_1} →
{β : Type u_2} →
[inst : MeasurableSpace α] →
[inst_1 : PseudoEMetricSpace α] →
[OpensMeasurableSpace α] →
[inst_3 : MeasurableSpace β] →
(f : β → α) →
Measurable f →
(s : Set α) →
(y₀ : α) → y₀ ∈ s → [TopologicalSpace.SeparableSpace ↑s] → ℕ → MeasureTheory.SimpleFunc β α | true |
AddCon.comapQuotientEquivOfSurj_symm_mk' | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (c : AddCon M) (f : N ≃+ M) (x : N),
(c.comapQuotientEquivOfSurj ↑f ⋯).symm ⟦f x⟧ = ↑x | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.getVert_sub_one_ne_getVert_add_one._proof_1_6 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} {i : ℕ} {p : G.Walk u u}, ¬i ≥ p.length - 1 → i + 1 ≤ p.length - 1 | false |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.isNilpotent_iff._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M],
LieModule.IsNilpotent L M = ∃ k, LieModule.lowerCentralSeries ℤ L M k = ⊥ | false |
List.isGE_compare_nil_right | Init.Data.Ord.Basic | ∀ {α : Type u_1} [inst : Ord α] {xs : List α}, (compare xs []).isGE = true | true |
IsOpen.isEverywherePos | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α}
[μ.IsOpenPosMeasure], IsOpen s → μ.IsEverywherePos s | true |
CategoryTheory.CatEnrichedOrdinary.instQuiverHom | Mathlib.CategoryTheory.Bicategory.CatEnriched | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] →
{X Y : CategoryTheory.CatEnrichedOrdinary C} → Quiver (X ⟶ Y) | true |
ftaylorSeriesWithin_fun_zero | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F],
(ftaylorSeriesWithin 𝕜 fun x => 0) = 0 | true |
Finset.sum_boole_mul | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonAssocSemiring R] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → R) (i : ι),
∑ j ∈ s, (if i = j then 1 else 0) * f j = if i ∈ s then f i else 0 | true |
BilinForm.toMatrix_apply | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (b : Module.Basis n R₁ M₁)
(B : LinearMap.BilinForm R₁ M₁) (i j : n), (LinearMap.BilinForm.toMatrix b) B i j = (B (b i)) (b j) | true |
ContinuousMultilinearMap.toMultilinearMap_add | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : ContinuousAdd M₂] (f g : ContinuousMultilinearMap R M₁ M₂),
(f + g).toMultilinearMap = f.toMultilinearMap + g.toMultilinearMap | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.noConfusion | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {P : Sort u_1} →
{C₀ : Type u₀} →
{C : Type u} →
{inst : CategoryTheory.Category.{v₀, u₀} C₀} →
{inst_1 : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C₀ C} →
{S : C} →
{t : F.PreOneHypercoverDenseData S} →
{C₀' : Type u₀} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v₀, u₀} C₀'} →
{inst'_1 : CategoryTheory.Category.{v, u} C'} →
{F' : CategoryTheory.Functor C₀' C'} →
{S' : C'} →
{t' : F'.PreOneHypercoverDenseData S'} →
C₀ = C₀' →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
F ≍ F' →
S ≍ S' →
t ≍ t' →
CategoryTheory.Functor.PreOneHypercoverDenseData.noConfusionType P t t' | false |
UInt32.toUInt64._proof_1 | Init.Data.UInt.BasicAux | 2 ^ 32 < 2 ^ 64 | false |
Dynamics.coverEntropyInf_eq_iSup_netEntropyInfEntourage | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} [inst : UniformSpace X] (T : X → X) (F : Set X),
Dynamics.coverEntropyInf T F = ⨆ U ∈ uniformity X, Dynamics.netEntropyInfEntourage T F U | true |
instContinuousSqrtNNReal._proof_1 | Mathlib.Topology.ContinuousMap.ContinuousSqrt | ContinuousOn (⇑NNReal.sqrt ∘ fun x => x.2 - x.1) {x | x.1 ≤ x.2} | false |
Nonneg.coeAddMonoidHom | Mathlib.Algebra.Order.Nonneg.Basic | {α : Type u_1} → [inst : AddMonoid α] → [inst_1 : Preorder α] → [inst_2 : AddLeftMono α] → { x // 0 ≤ x } →+ α | true |
RootPairing.coroot_mem_or_neg_mem_closure_of_root | Mathlib.LinearAlgebra.RootSystem.BaseExists | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [inst : AddCommGroup M]
[inst_1 : AddCommGroup N] [inst_2 : Field R] [CharZero R] [inst_4 : Module R M] [inst_5 : Module R N]
(P : RootPairing ι R M N) [P.IsRootSystem] [P.IsCrystallographic] [P.IsReduced] (s : Set ι),
LinearIndepOn R (⇑P.root) s →
(∀ (i : ι), P.root i ∈ AddSubmonoid.closure (⇑P.root '' s) ∨ -P.root i ∈ AddSubmonoid.closure (⇑P.root '' s)) →
∀ (i : ι),
P.coroot i ∈ AddSubmonoid.closure (⇑P.coroot '' s) ∨ -P.coroot i ∈ AddSubmonoid.closure (⇑P.coroot '' s) | true |
CategoryTheory.Arrow.arrow_mk_comp_eqToHom | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y Y' : T} (f : X ⟶ Y) (h : Y = Y'),
CategoryTheory.Arrow.mk (CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom h)) = CategoryTheory.Arrow.mk f | true |
egauge_empty | Mathlib.Analysis.Convex.EGauge | ∀ (𝕜 : Type u_1) [inst : NNNorm 𝕜] {E : Type u_2} [inst_1 : SMul 𝕜 E] (x : E), egauge 𝕜 ∅ x = ⊤ | true |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.SpectralObject.0.CategoryTheory.Triangulated.TStructure.spectralObject._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.SpectralObject | ¬0 ≤ 1 → False | false |
_private.Mathlib.Topology.Connected.Clopen.0.IsClopen.isPreconnected_iff._proof_1_6 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u_1} {s : Set α} (a b : Set α), s ⊆ a ∪ b → s = s ∩ a ∪ s ∩ b | false |
instIsScalarTowerTensorProductKaehlerDifferential._proof_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
IsScalarTower S (TensorProduct R S S) Ω[S⁄R] | false |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.isAtomic_of_complementedLattice._simp_1 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
List.getElem_set | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {i j : ℕ} {a : α} (h : j < (l.set i a).length), (l.set i a)[j] = if i = j then a else l[j] | true |
Lean.Meta.RefinedDiscrTree.LazyEntry.stack | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Lean.Meta.RefinedDiscrTree.LazyEntry → List Lean.Meta.RefinedDiscrTree.StackEntry | true |
Aesop.elabGlobalRuleIdent? | Aesop.RuleTac.ElabRuleTerm | Lean.Term → Lean.Elab.TermElabM (Option Lean.Name) | true |
Lean.Doc.Parser.header | Lean.DocString.Parser | Lean.Doc.Parser.BlockCtxt → Lean.Parser.ParserFn | true |
Int.neg_one_pow_ne_zero | Mathlib.Data.Int.Order.Units | ∀ {n : ℕ}, (-1) ^ n ≠ 0 | true |
StdSimplex.map | Mathlib.LinearAlgebra.ConvexSpace | {R : Type u} →
[inst : PartialOrder R] →
[inst_1 : Semiring R] →
[IsStrictOrderedRing R] → {M : Type v} → {N : Type w} → (M → N) → StdSimplex R M → StdSimplex R N | true |
List.nodup_append | Init.Data.List.Pairwise | ∀ {α : Type u_1} {l₁ l₂ : List α}, (l₁ ++ l₂).Nodup ↔ l₁.Nodup ∧ l₂.Nodup ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, a ≠ b | true |
leOfOrd | Init.Data.Ord.Basic | {α : Type u_1} → [Ord α] → LE α | true |
Lean.Expr.lt | Lean.Expr | Lean.Expr → Lean.Expr → Bool | true |
_private.Lean.Meta.Transform.0.Lean.Meta.unfoldDeclsFrom.match_1 | Lean.Meta.Transform | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((info : Lean.ConstantInfo) → motive (some info)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | false |
DFinsupp.sigmaCurryLEquiv_symm_apply | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} [inst : Semiring R] [inst_1 : DecidableEq ι] {α : ι → Type u_7}
{M : (i : ι) → α i → Type u_8} [inst_2 : (i : ι) → (j : α i) → AddCommMonoid (M i j)]
[inst_3 : (i : ι) → (j : α i) → Module R (M i j)] (a : Π₀ (i : ι) (j : α i), M i j),
DFinsupp.sigmaCurryLEquiv.symm a = DFinsupp.sigmaCurryEquiv.symm a | true |
Lean.ScopedEnvExtension.mk._flat_ctor | Lean.ScopedEnvExtension | {α β σ : Type} →
Lean.ScopedEnvExtension.Descr α β σ →
Lean.PersistentEnvExtension (Lean.ScopedEnvExtension.Entry α) (Lean.ScopedEnvExtension.Entry β)
(Lean.ScopedEnvExtension.StateStack α β σ) →
Lean.ScopedEnvExtension α β σ | false |
WeierstrassCurve.b₂_of_char_two | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [CharP R 2], W.b₂ = W.a₁ ^ 2 | true |
_private.Mathlib.Topology.Compactness.Lindelof.0.IsLindelof.disjoint_nhdsSet_right._simp_1_1 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = Disjoint b a | false |
_private.Mathlib.Order.Monotone.Defs.0.AntitoneOn._proof_2 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
(∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a ≤ b → f b ≤ f a) = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → b ≤ a → f a ≤ f b | false |
Matrix.zero | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} → {n : Type u_3} → {α : Type v} → [Zero α] → Zero (Matrix m n α) | true |
_private.Init.Data.Vector.Extract.0.Vector.extract_sub_one._proof_1 | Init.Data.Vector.Extract | ∀ {n i j : ℕ}, j < n → ¬min j n - i - 1 = min (j - 1) n - i → False | false |
MeasurableEquiv.prodSumDistrib | Mathlib.MeasureTheory.MeasurableSpace.Embedding | (α : Type u_6) →
(β : Type u_7) →
(γ : Type u_8) →
[inst : MeasurableSpace α] →
[inst_1 : MeasurableSpace β] → [inst_2 : MeasurableSpace γ] → α × (β ⊕ γ) ≃ᵐ α × β ⊕ α × γ | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Moebius.0.ArithmeticFunction.moebius_ne_zero_iff_eq_or._proof_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Moebius | ∀ {n : ℕ},
ArithmeticFunction.moebius n = 0 ∨ ArithmeticFunction.moebius n = 1 ∨ ArithmeticFunction.moebius n = -1 →
(¬ArithmeticFunction.moebius n = 0 ↔ ArithmeticFunction.moebius n = 1 ∨ ArithmeticFunction.moebius n = -1) | false |
CategoryTheory.Comonad.beckCoalgebraEqualizer._proof_1 | Mathlib.CategoryTheory.Monad.Equalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Comonad C} (X : T.Coalgebra)
(s :
CategoryTheory.Limits.Fork (CategoryTheory.Comonad.CofreeEqualizer.topMap X)
(CategoryTheory.Comonad.CofreeEqualizer.bottomMap X)),
(CategoryTheory.CategoryStruct.comp s.ι (CategoryTheory.Comonad.CofreeEqualizer.topMap X)).f =
(CategoryTheory.CategoryStruct.comp s.ι (CategoryTheory.Comonad.CofreeEqualizer.bottomMap X)).f | false |
TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] {s : Set R} {z : R},
z ∈ TwoSidedIdeal.span s ↔ z ∈ AddSubgroup.closure (Set.univ * s * Set.univ) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.