name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.List.Lemmas.0.List.mem_eraseDupsBy_loop | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l acc : List α},
a ∈ List.eraseDupsBy.loop (fun x1 x2 => x1 == x2) l acc ↔ a ∈ l ∨ a ∈ acc | true |
LieModule.Weight.genWeightSpaceOf_ne_bot | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] (χ : LieModule.Weight R L M) (x : L), LieModule.genWeightSpaceOf ... | true |
CategoryTheory.MorphismProperty.Comma.mapLeftIso._proof_3 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | false |
IsLocalFrameOn.toBasisAt_coe | Mathlib.Geometry.Manifold.VectorBundle.LocalFrame | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | true |
Submonoid.units_inf | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S T : Submonoid M), (S ⊓ T).units = S.units ⊓ T.units | true |
NormedSpace.exp_add_of_commute | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝔸 : Type u_1} [inst : NormedRing 𝔸] [NormedAlgebra ℚ 𝔸] [CompleteSpace 𝔸] {x y : 𝔸},
Commute x y → NormedSpace.exp (x + y) = NormedSpace.exp x * NormedSpace.exp y | true |
Tropical.add_eq_zero_iff | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LinearOrder R] {a b : Tropical (WithTop R)}, a + b = 0 ↔ a = 0 ∧ b = 0 | true |
Lean.Meta.PostponedEntry.noConfusion | Lean.Meta.Basic | {P : Sort u} → {t t' : Lean.Meta.PostponedEntry} → t = t' → Lean.Meta.PostponedEntry.noConfusionType P t t' | false |
_private.Std.Data.DHashMap.Internal.Raw.0.Std.DHashMap.Raw.Const.getThenInsertIfNew?.eq_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Raw α fun x => β) (a : α) (b : β),
Std.DHashMap.Raw.Const.getThenInsertIfNew? m a b =
if h : 0 < m.buckets.size then
match Std.DHashMap.Internal.Raw₀.Const.getThenInsertIfNew? ⟨m, h⟩ a b with
| (replaced, ⟨r, property⟩)... | true |
IsMulCommutative.is_comm | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} {inst : Mul M} [self : IsMulCommutative M], Std.Commutative fun x1 x2 => x1 * x2 | true |
Std.Internal.IO.Async.System.SystemUser.noConfusionType | Std.Internal.Async.System | Sort u → Std.Internal.IO.Async.System.SystemUser → Std.Internal.IO.Async.System.SystemUser → Sort u | false |
CategoryTheory.Limits.WalkingMulticospan.Hom._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} → {x x_1 : CategoryTheory.Limits.WalkingMulticospan J} → x.Hom x_1 → ℕ | false |
Valued.valueGroup₀_hom_extensionValuation.eq_1 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀],
Valued.valueGroup₀_hom_extensionValuation =
{ toFun := fun x => Valued.extensionValuation.restrict ↑⋯.choose, map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } | true |
PiTensorProduct.instAddCommMonoidWithOne._proof_1 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : ι → Type u_3} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoidWithOne (A i)] [inst_2 : (i : ι) → Module R (A i)], Nat.unaryCast 0 = 0 | false |
IsEmpty.exists_iff._simp_1 | Mathlib.Logic.IsEmpty.Defs | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∃ a, p a) = False | false |
ProbabilityTheory.HasLaw.isFiniteMeasure | Mathlib.Probability.HasLaw | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧} {X : Ω → 𝓧}
{μ : MeasureTheory.Measure 𝓧} {P : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure μ],
ProbabilityTheory.HasLaw X μ P → MeasureTheory.IsFiniteMeasure P | true |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Simplex.ExcenterExists.touchpoint_ne_point._simp_1_7 | Mathlib.Geometry.Euclidean.Incenter | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | false |
ProbabilityTheory.Kernel.IsProper.setLIntegral_inter_eq_indicator_mul_setLIntegral | Mathlib.Probability.Kernel.Proper | ∀ {X : Type u_1} {𝓑 𝓧 : MeasurableSpace X} {π : ProbabilityTheory.Kernel X X} {A B : Set X} {f : X → ENNReal},
π.IsProper →
𝓑 ≤ 𝓧 →
Measurable f →
MeasurableSet A →
MeasurableSet B → ∀ (x₀ : X), ∫⁻ (x : X) in A ∩ B, f x ∂π x₀ = B.indicator 1 x₀ * ∫⁻ (x : X) in A, f x ∂π x₀ | true |
starLinearEquiv._proof_3 | Mathlib.Algebra.Star.Module | ∀ {A : Type u_1} [inst : AddCommMonoid A] [inst_1 : StarAddMonoid A],
Function.LeftInverse starAddEquiv.invFun starAddEquiv.toFun | false |
NumberField.mixedEmbedding.stdBasis.eq_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.stdBasis K =
(Pi.basisFun ℝ { w // w.IsReal }).prod
((Pi.basis fun x => Complex.basisOneI).reindex (Equiv.sigmaEquivProd { w // w.IsComplex } (Fin 2))) | true |
_private.Aesop.Script.StructureStatic.0.Aesop.Script.structureStaticCore.go.match_1 | Aesop.Script.StructureStatic | (motive : List Aesop.Script.Step × Aesop.Script.TacticState → Sort u_1) →
(__discr : List Aesop.Script.Step × Aesop.Script.TacticState) →
((tailScript : List Aesop.Script.Step) →
(tacticState : Aesop.Script.TacticState) → motive (tailScript, tacticState)) →
motive __discr | false |
AddCommute.neg_neg | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, AddCommute a b → AddCommute (-a) (-b) | true |
Pi.uniqueOfIsEmpty | Mathlib.Logic.Unique | {α : Sort u_1} → [IsEmpty α] → (β : α → Sort v) → Unique ((a : α) → β a) | true |
Ordering.isGE_eq_false | Init.Data.Ord.Basic | ∀ {o : Ordering}, o.isGE = false ↔ o = Ordering.lt | true |
Prod.isScalarTowerBoth | Mathlib.Algebra.Group.Action.Prod | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Mul N] [inst_1 : Mul P] [inst_2 : SMul M N] [inst_3 : SMul M P]
[IsScalarTower M N N] [IsScalarTower M P P], IsScalarTower M (N × P) (N × P) | true |
Std.TreeSet.mem_iff_contains | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {k : α}, k ∈ t ↔ t.contains k = true | true |
PNat.coe_inj._simp_1 | Mathlib.Data.PNat.Basic | ∀ {m n : ℕ+}, (↑m = ↑n) = (m = n) | false |
Lean.IR.FnBody.set.elim | Lean.Compiler.IR.Basic | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
t.ctorIdx = 2 →
((x : Lean.IR.VarId) →
(i : ℕ) → (y : Lean.IR.Arg) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.set x i y b)) →
motive_2 t | false |
InfHom.const_apply | Mathlib.Order.Hom.Lattice | ∀ (α : Type u_2) {β : Type u_3} [inst : Min α] [inst_1 : SemilatticeInf β] (b : β) (a : α), (InfHom.const α b) a = b | true |
CoalgCat.toModuleCat | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} → [inst : CommRing R] → CoalgCat R → ModuleCat R | true |
continuousMultilinearCurryFin1_apply | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ {𝕜 : Type u} {G : Type wG} {G' : Type wG'} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G']
(f : ContinuousMultilinearMap 𝕜 (fun i => G) G') (x : G),
((continuousMultilinearCurryFin1 𝕜 G G') f) x = f ... | true |
Batteries.RBNode.lowerBound?._sunfold | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Ordering) → Batteries.RBNode α → optParam (Option α) none → Option α | false |
Std.Channel.instAsyncStreamOfInhabited | Std.Sync.Channel | {α : Type} → [Inhabited α] → Std.Internal.Async.IO.AsyncStream (Std.Channel α) α | true |
NonUnitalSubalgebra.range_val | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(S : NonUnitalSubalgebra R A), NonUnitalAlgHom.range (NonUnitalSubalgebraClass.subtype S) = S | true |
AddCommSemigroup | Mathlib.Algebra.Group.Defs | Type u → Type u | true |
Tropical.instCommMonoidTropical._proof_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : AddCommMonoid R] (a b : Tropical R), a * b = b * a | false |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.Measurable.simpleFunc_add._simp_1_3 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {a : Prop}, (¬¬a) = a | false |
_private.Std.Internal.Http.Data.URI.Parser.0.Std.Http.URI.Parser.parseAuthority | Std.Internal.Http.Data.URI.Parser | Std.Http.URI.Config → Std.Internal.Parsec.ByteArray.Parser Std.Http.URI.Authority | true |
Lean.Meta.IndPredBelow.RecursionContext.motives | Lean.Meta.IndPredBelow | Lean.Meta.IndPredBelow.RecursionContext → Lean.FVarIdMap (ℕ × Lean.Expr) | true |
OrderIso.sumLexDualAntidistrib_inr | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (b : β),
(OrderIso.sumLexDualAntidistrib α β) (OrderDual.toDual (Sum.inr b)) = Sum.inl (OrderDual.toDual b) | true |
QuadraticMap.isometryEquivBasisRepr | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_4} →
{N : Type u_9} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
[inst_5 : Finite ι] →
... | true |
CategoryTheory.WithInitial.equivComma_counitIso_inv_app_left | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(X : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D))),
(CategoryTheory.WithInitial.equivComma.counitIso.inv.app X).left = CategoryThe... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_union_of_left._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.measure_isHaarMeasure_eq_smul_of_isEverywherePos._simp_1_14 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | false |
Int32.toInt_add | Init.Data.SInt.Lemmas | ∀ (a b : Int32), (a + b).toInt = (a.toInt + b.toInt).bmod (2 ^ 32) | true |
IO.FileRight._sizeOf_1 | Init.System.IO | IO.FileRight → ℕ | false |
AddChar.to_mulShift_inj_of_isPrimitive | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {R : Type u} [inst : CommRing R] {R' : Type v} [inst_1 : CommMonoid R'] {ψ : AddChar R R'},
ψ.IsPrimitive → Function.Injective ψ.mulShift | true |
Turing.ToPartrec.instDecidableEqCode.decEq._proof_9 | Mathlib.Computability.TuringMachine.Config | ¬Turing.ToPartrec.Code.succ = Turing.ToPartrec.Code.zero' | false |
Matrix.SpecialLinearGroup.instGroup._proof_1 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_2} [inst_2 : CommRing R]
(a b : Matrix.SpecialLinearGroup n R), a / b = a * b⁻¹ | false |
T25Space.mk._flat_ctor | Mathlib.Topology.Separation.Regular | ∀ {X : Type u} [inst : TopologicalSpace X],
(∀ ⦃x y : X⦄, x ≠ y → Disjoint ((nhds x).lift' closure) ((nhds y).lift' closure)) → T25Space X | false |
Lean.Compiler.LCNF.Simp.JpCasesInfo.ctorIdx | Lean.Compiler.LCNF.Simp.JpCases | Lean.Compiler.LCNF.Simp.JpCasesInfo → ℕ | false |
_private.Lean.Compiler.LCNF.Main.0.Lean.Compiler.LCNF.isValidMainType._sparseCasesOn_7 | Lean.Compiler.LCNF.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 160 t.ctorIdx → m... | false |
Right.nsmul_nonpos | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddRightMono M] {x : M}, x ≤ 0 → ∀ {n : ℕ}, n • x ≤ 0 | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.iteratedDerivWithin_cot_pi_mul_eq_mul_tsum_div_pow._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {k : ℕ}, Int.negSucc 0 - ↑k = Int.negSucc k | false |
MeasureTheory.Egorov.notConvergentSeq | Mathlib.MeasureTheory.Function.Egorov | {α : Type u_1} →
{β : Type u_2} → {ι : Type u_3} → [PseudoEMetricSpace β] → [Preorder ι] → (ι → α → β) → (α → β) → ℕ → ι → Set α | true |
_private.Init.Data.Nat.Fold.0.Nat.dfold_loop_succ._proof_14 | Init.Data.Nat.Fold | ∀ {n j : ℕ}, j ≤ n → ¬n + 1 - (j + 1) = n - j → False | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_5 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₀ n₁ : ℤ), autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.shortComplexMap._auto_1 → n₀ + 1 = n₁ | false |
ShrinkingLemma.PartialRefinement.exists_gt | Mathlib.Topology.ShrinkingLemma | ∀ {ι : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {u : ι → Set X} {s : Set X} [NormalSpace X]
(v : ShrinkingLemma.PartialRefinement u s ⊤), IsClosed s → ∀ i ∉ v.carrier, ∃ v', v < v' | true |
IsOpen.trivializationDiscrete | Mathlib.Topology.Covering.Basic | {E : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace X] →
{f : E → X} →
[Nonempty (X → E)] →
{ι : Type u_3} →
[Nonempty ι] →
[inst_4 : TopologicalSpace ι] →
[DiscreteTopology ι] →
... | true |
Algebra.rank_eq_of_equiv_equiv | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type w} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {R' : Type w'}
[inst_3 : CommSemiring R'] {S' : Type v} [inst_4 : Semiring S'] [inst_5 : Algebra R' S'] (i : R ≃+* R')
(j : S ≃+* S'),
(algebraMap R' S').comp i.toRingHom = j.toRingHom.comp (algebraMap R S) → Module.r... | true |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.pow_sub_lt_descFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (k : ℕ), motive k.succ.succ) → motive x | false |
NumberField.ComplexEmbedding.IsConj.isUnramified_mk_iff | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Gal(K/k)} {φ : K →+* ℂ},
NumberField.ComplexEmbedding.IsConj φ σ →
(NumberField.InfinitePlace.IsUnramified k (NumberField.InfinitePlace.mk φ) ↔ σ = 1) | true |
Lean.Compiler.LCNF.ReduceArity.Context.paramMask | Lean.Compiler.LCNF.ReduceArity | Lean.Compiler.LCNF.ReduceArity.Context → Array Bool | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme___macroRules__private_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme_0_AlgebraicGeometry_termA⁰___1» | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.Macro | false |
_private.Mathlib.Algebra.Ring.CentroidHom.0.CentroidHom._aux_Mathlib_Algebra_Ring_CentroidHom___unexpand_AddMonoid_End_mulLeft_1 | Mathlib.Algebra.Ring.CentroidHom | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.IdealSheafData.glueDataT'Aux._proof_4 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U V W U₀ : ↑X.affineOpens) (hU₀ : ↑U ⊓ ↑W ≤ ↑U₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (I.glueDataObjι U) (X.homOfLE ⋯))
(CategoryT... | false |
CategoryTheory.OverClass.ofHom._flat_ctor | Mathlib.CategoryTheory.Comma.Over.OverClass | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X S : C} → (X ⟶ S) → CategoryTheory.OverClass X S | false |
CategoryTheory.PreZeroHypercover.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} → (I₀ : Type w) → (X : I₀ → C) → ((i : I₀) → X i ⟶ S) → CategoryTheory.PreZeroHypercover S | false |
Num.cast_bit0._simp_1 | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : NonAssocSemiring α] (n : Num), 2 * ↑n = ↑n.bit0 | false |
isExclusiveUnsafe | Init.Util | {α : Type u} → α → Bool | true |
List.getElem_range'_1 | Mathlib.Data.List.Range | ∀ {n m : ℕ} (i : ℕ) (H : i < (List.range' n m).length), (List.range' n m)[i] = n + i | true |
Std.ExtDTreeMap.Const.getKey?_insertManyIfNewUnit_list_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
{l : List α} {k : α}, k ∈ t → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKey? k = t.getKey? k | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.neg_fdiv._proof_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℤ}, ¬0 ≤ b → ¬b < 0 → False | false |
Lean.Sym.UInt64.lt_eq_true | Init.Sym.Lemmas | ∀ (a b : UInt64), decide (a < b) = true → (a < b) = True | true |
rootsOfUnity.eq_one | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} {r : ↥(rootsOfUnity n R)}, n = 1 → ↑r = 1 | true |
Submodule.forall_mem_sup._simp_1 | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p p' : Submodule R M) {P : M → Prop}, (∀ x ∈ p ⊔ p', P x) = ∀ x₁ ∈ p, ∀ x₂ ∈ p', P (x₁ + x₂) | false |
differentiableAt_id | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {x : E}, DifferentiableAt 𝕜 id x | true |
Finset.smul_mem_smul_finset_iff₀ | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : GroupWithZero α] [inst_2 : MulAction α β]
{s : Finset β} {a : α} {b : β}, a ≠ 0 → (a • b ∈ a • s ↔ b ∈ s) | true |
Isocrystal.«_aux_Mathlib_RingTheory_WittVector_Isocrystal___macroRules_Isocrystal_term_→ᶠⁱ[_,_]__1» | Mathlib.RingTheory.WittVector.Isocrystal | Lean.Macro | false |
vectorAllP_cons._simp_1 | Mathlib.Data.Vector3 | ∀ {α : Type u_1} {n : ℕ} (p : α → Prop) (x : α) (v : Vector3 α n),
VectorAllP p (Vector3.cons x v) = (p x ∧ VectorAllP p v) | false |
AddMonoid.exponent_eq_zero_iff_forall | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddMonoid G], AddMonoid.exponent G = 0 ↔ ∀ n > 0, ∃ g, n • g ≠ 0 | true |
StrictConvexSpace.rec | Mathlib.Analysis.Convex.StrictConvexSpace | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : NormedField 𝕜] →
[inst_1 : PartialOrder 𝕜] →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{motive : StrictConvexSpace 𝕜 E → Sort u} →
((strictConvex_closedBall : ∀ (r : ℝ), 0 < r → StrictConvex 𝕜 (M... | false |
Std.DTreeMap.Raw.Equiv.modify | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (k : α) (f : β k → β k), (t₁.modify k f).Equiv (t₂.modify k f) | true |
Real.fourierChar._proof_2 | Mathlib.Analysis.Complex.Circle | ∀ (x y : ℝ), Circle.exp (2 * Real.pi * (x + y)) = Circle.exp (2 * Real.pi * x) * Circle.exp (2 * Real.pi * y) | false |
Ordnode.splitMin'.eq_def | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (x : Ordnode α) (x_1 : α) (x_2 : Ordnode α),
x.splitMin' x_1 x_2 =
match x, x_1, x_2 with
| Ordnode.nil, x, r => (x, r)
| Ordnode.node size ll lx lr, x, r =>
match ll.splitMin' lx lr with
| (xm, l') => (xm, l'.balanceR x r) | true |
CategoryTheory.IsPushout.recOn | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Z X Y P : C} →
{f : Z ⟶ X} →
{g : Z ⟶ Y} →
{inl : X ⟶ P} →
{inr : Y ⟶ P} →
{motive : CategoryTheory.IsPushout f g inl inr → Sort u} →
(t : CategoryTheory.IsPushout f g inl inr) →
... | false |
SpectralSpace.mk | Mathlib.Topology.Spectral.Basic | ∀ {X : Type u_3} [inst : TopologicalSpace X] [toT0Space : T0Space X] [toCompactSpace : CompactSpace X]
[toQuasiSober : QuasiSober X] [toQuasiSeparatedSpace : QuasiSeparatedSpace X]
[toPrespectralSpace : PrespectralSpace X], SpectralSpace X | true |
Lean.Meta.InjectionsResult._sizeOf_inst | Lean.Meta.Tactic.Injection | SizeOf Lean.Meta.InjectionsResult | false |
Std.HashMap.Raw.unitOfArray | Std.Data.HashMap.Raw | {α : Type u} → [BEq α] → [Hashable α] → Array α → Std.HashMap.Raw α Unit | true |
BialgCat.toBialgHom_comp | Mathlib.Algebra.Category.BialgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {X Y Z : BialgCat R} (f : X ⟶ Y) (g : Y ⟶ Z),
BialgCat.Hom.toBialgHom (CategoryTheory.CategoryStruct.comp f g) =
(BialgCat.Hom.toBialgHom g).comp (BialgCat.Hom.toBialgHom f) | true |
Ordinal.range_omega | Mathlib.SetTheory.Cardinal.Aleph | Set.range ⇑Ordinal.omega = {x | Ordinal.omega0 ≤ x ∧ x.IsInitial} | true |
HeytingHom.noConfusionType | Mathlib.Order.Heyting.Hom | Sort u →
{α : Type u_6} →
{β : Type u_7} →
[inst : HeytingAlgebra α] →
[inst_1 : HeytingAlgebra β] →
HeytingHom α β →
{α' : Type u_6} →
{β' : Type u_7} → [inst' : HeytingAlgebra α'] → [inst'_1 : HeytingAlgebra β'] → HeytingHom α' β' → Sort u | false |
_private.Mathlib.RingTheory.Ideal.Height.0.exists_spanRank_le_and_le_height_of_le_height._simp_1_2 | Mathlib.RingTheory.Ideal.Height | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension._aux_Mathlib_RingTheory_Valuation_Extension___unexpand_Valuation_valuationSubring_1 | Mathlib.RingTheory.Valuation.Extension | Lean.PrettyPrinter.Unexpander | false |
ContinuousAffineMap.const | Mathlib.Topology.Algebra.ContinuousAffineMap | (R : Type u_1) →
{V : Type u_2} →
{W : Type u_3} →
(P : Type u_4) →
{Q : Type u_5} →
[inst : Ring R] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module R V] →
[inst_3 : TopologicalSpace P] →
[inst_4 : AddTorsor V P] →
... | true |
Mathlib.Linter.CountHeartbeats.«command#count_heartbeatsApproximately» | Mathlib.Util.CountHeartbeats | Lean.ParserDescr | true |
dist_mul_right | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} [inst : Mul M] [inst_1 : PseudoMetricSpace M] [IsIsometricSMul Mᵐᵒᵖ M] (a b c : M),
dist (a * c) (b * c) = dist a b | true |
CategoryTheory.Limits.KernelFork.isLimitOfIsLimitOfIff'._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {g : X ⟶ Y} {Y' : C} (g' : X ⟶ Y'),
(∀ ⦃W : C⦄ (φ : W ⟶ X), CategoryTheory.CategoryStruct.comp φ g = 0 ↔ CategoryTheory.CategoryStruct.comp φ g' = 0) →
∀ ⦃W : C⦄ (φ : W ⟶ X),
Catego... | false |
mulLeftEmbedding.congr_simp | Mathlib.Algebra.Group.Embedding | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : IsLeftCancelMul G] (g g_1 : G),
g = g_1 → mulLeftEmbedding g = mulLeftEmbedding g_1 | true |
CategoryTheory.Lax.StrongTrans.mkOfLax._proof_2 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} (η : CategoryTheory.Lax.LaxTrans F G) (η' : η.StrongCore) {a b : B}
{f g : a ⟶ b} (η_1 : f ⟶ g),
CategoryTheory.CategoryStruct.comp (η'.naturality f).hom
(Categor... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.