name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.AlgebraicGeometry.PullbackCarrier.0.AlgebraicGeometry.Scheme.Pullback.SpecTensorTo_SpecOfPoint._simp_1_2 | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↥X),
g (f x) = (CategoryTheory.CategoryStruct.comp f g) x | false |
Matrix.instSMulCommClassForall_1 | Mathlib.Data.Matrix.Action | ∀ {n : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : DistribSMul S R] [SMulCommClass S R R], SMulCommClass S (Matrix n n R) (n → R) | true |
condM | Mathlib.Control.Combinators | {m : Type → Type} → [Monad m] → {α : Type} → m Bool → m α → m α → m α | true |
ContinuousAlternatingMap.restrictScalarsCLM._proof_2 | Mathlib.Topology.Algebra.Module.Alternating.Topology | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F] (𝕜' : Type u_2)
[inst_3 : NontriviallyNormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜' 𝕜] [inst_5 : Module 𝕜' F] [IsScalarTower 𝕜' 𝕜 F],
SMulCommClass 𝕜 𝕜' F | false |
FP.Float.inf.injEq | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg] (a a_1 : Bool), (FP.Float.inf a = FP.Float.inf a_1) = (a = a_1) | true |
Lean.Grind.CommRing.Expr.toPoly.eq_10 | Init.Grind.Ring.CommSolver | ∀ (k : ℕ) (n : ℤ),
((Lean.Grind.CommRing.Expr.intCast n).pow k).toPoly =
bif k == 0 then Lean.Grind.CommRing.Poly.num 1 else Lean.Grind.CommRing.Poly.num (n ^ k) | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach.0.Std.Iterators.Types.Attach.Monadic.modifyStep.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β] {P : β → Prop}
(it : Std.IterM m { out // P out }) (it' : Std.IterM m β)
(h : it.internalState.inner.IsPlausibleStep (Std.IterStep.skip it')),
Std.Iterators.Types.Attach.Monadic.modifyStep it ⟨Std.IterStep.skip it', h⟩ =
Std.IterSt... | true |
Nat.getElem!_toArray_rio_eq_zero_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, (*...n).toArray[i]! = 0 ↔ n ≤ i ∨ i = 0 | true |
Char.le_total | Init.Data.Char.Lemmas | ∀ (a b : Char), a ≤ b ∨ b ≤ a | true |
Submonoid.mem_biSup_of_directedOn | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : MulOneClass M] {ι : Type u_4} {p : ι → Prop} {K : ι → Submonoid M} {i : ι},
p i →
DirectedOn (Function.onFun (fun x1 x2 => x1 ≤ x2) K) {i | p i} →
∀ {x : M}, x ∈ ⨆ i, ⨆ (_ : p i), K i ↔ ∃ i, p i ∧ x ∈ K i | true |
sizeOf_nat | Init.SizeOf | ∀ (n : ℕ), sizeOf n = n | true |
UniformConvergenceCLM.instAddCommGroup._proof_7 | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | false |
YoungDiagram.colLen_eq_card | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ : YoungDiagram) {j : ℕ}, μ.colLen j = (μ.col j).card | true |
PosNum.distrib._proof_2 | Mathlib.Data.Num.Lemmas | ∀ (a b c : PosNum), (a + b) * c = a * c + b * c | false |
Algebra.SubmersivePresentation.coeffs | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] → [inst_3 : Finite σ] → Algebra.SubmersivePresentation R S ι σ → Set R | true |
PosNum | Mathlib.Data.Num.Basic | Type | true |
PerfectField.ofCharZero | Mathlib.FieldTheory.Perfect | ∀ {K : Type u_1} [inst : Field K] [CharZero K], PerfectField K | true |
Lean.Compiler.LCNF.ToLCNF.mustEtaExpand | Lean.Compiler.LCNF.ToLCNF | Lean.Environment → Lean.Expr → Bool | true |
Std.ExtDTreeMap.getKey! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → [Inhabited α] → Std.ExtDTreeMap α β cmp → α → α | true |
CompleteBooleanAlgebra.toCompl | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} → [self : CompleteBooleanAlgebra α] → Compl α | true |
CategoryTheory.unop_whiskerRight | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : Cᵒᵖ}
(f : X ⟶ Y) (Z : Cᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z).unop =
CategoryTheory.MonoidalCategoryStruct.whiskerRight f.unop (Opposite.unop Z) | true |
sub_toIcoDiv_zsmul_mem_Ico | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), b - toIcoDiv hp a b • p ∈ Set.Ico a (a + p) | true |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.funProp.match_1 | Mathlib.Tactic.FunProp.Core | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) ... | false |
Multiset.map_add_right_Icc | Mathlib.Algebra.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelAddMonoid α] [ExistsAddOfLE α]
[inst_4 : LocallyFiniteOrder α] (a b c : α),
Multiset.map (fun x => x + c) (Multiset.Icc a b) = Multiset.Icc (a + c) (b + c) | true |
Finset.max'_pair | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (a b : α), {a, b}.max' ⋯ = max a b | true |
QuadraticMap.associated._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N], IsScalarTower R R N | false |
Lean.Lsp.DiagnosticSeverity._sizeOf_inst | Lean.Data.Lsp.Diagnostics | SizeOf Lean.Lsp.DiagnosticSeverity | false |
Real.fourierIntegral_continuousMultilinearMap_apply | Mathlib.Analysis.Fourier.FourierTransform | ∀ {V : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V] [inst_6 : FiniteDimensional ℝ V]
{ι : Type u_4} [inst_7 : Fintype ι] {M : ι → Type u_5} [inst_8 : (i : ι) → N... | true |
Lean.instToJsonList | Lean.Data.Json.FromToJson.Basic | {α : Type u_1} → [Lean.ToJson α] → Lean.ToJson (List α) | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_427 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
¬[g a, g (g a)].Nodup →
∀ (w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, ... | false |
NonemptyFinLinOrd.hasForgetToFinPartOrd._proof_2 | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ {X Y Z : NonemptyFinLinOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
FinPartOrd.ofHom (LinOrd.Hom.hom (CategoryTheory.CategoryStruct.comp f g).hom) =
CategoryTheory.CategoryStruct.comp (FinPartOrd.ofHom (LinOrd.Hom.hom f.hom))
(FinPartOrd.ofHom (LinOrd.Hom.hom g.hom)) | false |
Lean.Elab.Term.FunBinders.State.noConfusionType | Lean.Elab.Binders | Sort u → Lean.Elab.Term.FunBinders.State → Lean.Elab.Term.FunBinders.State → Sort u | false |
DirectSum.GAlgebra.mk | Mathlib.Algebra.DirectSum.Algebra | {ι : Type uι} →
{R : Type uR} →
{A : ι → Type uA} →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
[inst_2 : (i : ι) → Module R (A i)] →
[inst_3 : AddMonoid ι] →
[inst_4 : DirectSum.GSemiring A] →
(toFun : R →+ A 0) →
... | true |
Tree.numNodes.eq_def | Mathlib.Data.Tree.Basic | ∀ {α : Type u} (x : Tree α),
x.numNodes =
match x with
| Tree.nil => 0
| Tree.node a a_1 b => a_1.numNodes + b.numNodes + 1 | true |
SimpleGraph.isEdgeReachable_comm | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ} {u v : V}, G.IsEdgeReachable k u v ↔ G.IsEdgeReachable k v u | true |
Congr!.Config.mk.sizeOf_spec | Mathlib.Tactic.CongrExclamation | ∀ (closePre closePost : Bool) (transparency preTransparency : Lean.Meta.TransparencyMode)
(preferLHS partialApp sameFun : Bool) (maxArgs : Option ℕ) (typeEqs etaExpand useCongrSimp beqEq : Bool),
sizeOf
{ closePre := closePre, closePost := closePost, transparency := transparency, preTransparency := preTranspa... | true |
NumberField.mixedEmbedding.fundamentalCone.expMapBasis_closure_subset_compactSet | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
↑NumberField.mixedEmbedding.fundamentalCone.expMapBasis ''
closure (NumberField.mixedEmbedding.fundamentalCone.paramSet K) ⊆
NumberField.mixedEmbedding.fundamentalCone.compactSet K | true |
IsOpenUnits.mk | Mathlib.Topology.Algebra.IsOpenUnits | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : TopologicalSpace M], Topology.IsOpenEmbedding Units.val → IsOpenUnits M | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Basic___delab_app__private_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Basic_0_termX_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | Lean.PrettyPrinter.Delaborator.Delab | false |
Rat.divInt_ofNat | Init.Data.Rat.Lemmas | ∀ (num : ℤ) (den : ℕ), Rat.divInt num ↑den = mkRat num den | true |
PiTensorProduct.tprodMonoidHom_apply | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_3) {A : ι → Type u_4} [inst : CommSemiring R] [inst_1 : (i : ι) → NonAssocSemiring (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : ∀ (i : ι), SMulCommClass R (A i) (A i)]
[inst_4 : ∀ (i : ι), IsScalarTower R (A i) (A i)] (a : (i : ι) → A i),
(PiTensorProduct.tprodMonoidHom R) a =... | true |
CategoryTheory.Oplax.StrongTrans.homCategory._proof_2 | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {X Y : F ⟶ G} (f : CategoryTheory.Oplax.StrongTrans.Hom X Y),
{ as := { as := CategoryTheory.Oplax.StrongTrans.Modification.id X }.as.vcomp f.as } = f | false |
CategoryTheory.Sieve.instCompleteLattice._proof_11 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : C} (x : Set (CategoryTheory.Sieve X)),
CategoryTheory.Sieve.sup x ∈ upperBounds x ∧ CategoryTheory.Sieve.sup x ∈ lowerBounds (upperBounds x) | false |
Real.logb_pow | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ (b x : ℝ) (k : ℕ), Real.logb b (x ^ k) = ↑k * Real.logb b x | true |
Nat.toDigits_length | Mathlib.Data.Nat.Digits.Defs | ∀ (b n e : ℕ), 0 < e → n < b ^ e → (b.toDigits n).length ≤ e | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono'_f' | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.LeftHomologyData) [inst_2 : CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
(CategoryT... | true |
_private.Init.Grind.Ring.CommSemiringAdapter.0.Lean.Grind.CommRing.Expr.toPolyS.match_4.eq_2 | Init.Grind.Ring.CommSemiringAdapter | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Var)
(h_1 : (n : ℤ) → motive (Lean.Grind.CommRing.Expr.num n))
(h_2 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_3 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_4 : (a b : Lean.Grind.CommRing.E... | true |
Affine.Simplex.affineCombination_mem_setInterior_face_iff_mem | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (I : Set k) {n : ℕ} (s : Affine.Simplex k P n) {fs : Finset (Fin (n + 1))} {m : ℕ}
(h : fs.card = m + 1) {w : Fin (n + 1) → k},
∑ i, w i = 1 →
((Finset.affineCombination k Fi... | true |
DistribMulAction.toAddEquiv_apply | Mathlib.Algebra.GroupWithZero.Action.Basic | ∀ {G : Type u_1} (A : Type u_3) [inst : Group G] [inst_1 : AddMonoid A] [inst_2 : DistribMulAction G A] (x : G) (a : A),
(DistribMulAction.toAddEquiv A x) a = x • a | true |
Aesop.instDecidableRelLevelIndexLe | Aesop.Forward.LevelIndex | DecidableRel fun x1 x2 => x1 ≤ x2 | true |
Std.DHashMap.Const.getD_filter_of_getKey?_eq_some | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Bool} {k k' : α} {fallback : β},
m.getKey? k = some k' →
Std.DHashMap.Const.getD (Std.DHashMap.filter f m) k fallback =
(Option.filter (fun x => f k' x) (Std.DHashMap.Con... | true |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.forwardMessages.handleMessage._sparseCasesOn_12 | Lean.Server.Watchdog | {motive : Lean.JsonRpc.ErrorCode → Sort u} →
(t : Lean.JsonRpc.ErrorCode) →
motive Lean.JsonRpc.ErrorCode.requestCancelled → (Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.cmp_eq._simp_1_2 | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → (a = b) = False | false |
CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_inv_left_app | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C)
(X_1 : SimplexCategoryᵒᵖ), X.rightOpLeftOpIso.inv.left.app X_1 = CategoryTheory.CategoryStruct.id (X.left.obj X_1) | true |
liftM_seqLeft | Init.Control.Lawful.MonadLift.Lemmas | ∀ {m : Type u → Type v} {n : Type u → Type w} [inst : Monad m] [inst_1 : Monad n] [inst_2 : MonadLiftT m n]
[LawfulMonadLiftT m n] {α β : Type u} [LawfulMonad m] [LawfulMonad n] (x : m α) (y : m β),
liftM (x <* y) = liftM x <* liftM y | true |
MeasureTheory.hitting_le_iff_of_exists | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β}
{n i : ι} {ω : Ω} [WellFoundedLT ι] {m : ι},
(∃ j ∈ Set.Icc n m, u j ω ∈ s) → (MeasureTheory.hittingBtwn u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s) | true |
TopologicalSpace.nhds_mkOfNhds | Mathlib.Topology.Order | ∀ {α : Type u} (n : α → Filter α) (a : α), pure ≤ n → (∀ (a : α), ∀ s ∈ n a, ∀ᶠ (y : α) in n a, s ∈ n y) → nhds a = n a | true |
Turing.idComputableInPolyTime | Mathlib.Computability.TuringMachine.Computable | {α αΓ : Type} → [Fintype αΓ] → (ea : α → List αΓ) → Turing.TM2ComputableInPolyTime ea ea id | true |
Cardinal.continuum_pos | Mathlib.SetTheory.Cardinal.Continuum | 0 < Cardinal.continuum | true |
fderiv_const_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} (c : F), fderiv 𝕜 (fun y => c - f y) x = -fderiv 𝕜 f x | true |
Computability.unary_decode_encode_nat | Mathlib.Computability.Encoding | ∀ (n : ℕ), Computability.unaryDecodeNat (Computability.unaryEncodeNat n) = n | true |
CategoryTheory.GradedObject.isInitialSingleObjApply | Mathlib.CategoryTheory.GradedObject.Single | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Limits.HasInitial C] →
[inst_2 : DecidableEq J] →
(j : J) →
(X : C) → (i : J) → i ≠ j → CategoryTheory.Limits.IsInitial ((CategoryTheory.GradedObject.single j).obj X i) | true |
AlgebraicGeometry.Scheme.Modules.pseudofunctor_map_r | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : CategoryTheory.LocallyDiscrete AlgebraicGeometry.Schemeᵒᵖ} (f : X ⟶ Y),
(AlgebraicGeometry.Scheme.Modules.pseudofunctor.map f).r =
(AlgebraicGeometry.Scheme.Modules.pushforward f.as.unop).toCatHom | true |
Lean.Meta.Simp.NormCastConfig.mk | Init.MetaTypes | Lean.Meta.Simp.Config → Lean.Meta.Simp.NormCastConfig | true |
IntermediateField.fixingSubgroupEquiv._proof_7 | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_2} [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (K : IntermediateField F E)
(ϕ : ↥K.fixingSubgroup), ↑ϕ ∈ ↑K.fixingSubgroup | false |
ENNReal.mul_ne_top | Mathlib.Data.ENNReal.Operations | ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → a * b ≠ ⊤ | true |
Lean.Meta.Try.Collector.OrdSet.elems | Lean.Meta.Tactic.Try.Collect | {α : Type} → [inst : Hashable α] → [inst_1 : BEq α] → Lean.Meta.Try.Collector.OrdSet α → Array α | true |
Subring.comap_top | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R →+* S), Subring.comap f ⊤ = ⊤ | true |
MeasureTheory.mlconvolution_zero | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Mul G] [inst_1 : Inv G] (f : G → ENNReal)
(μ : MeasureTheory.Measure G), MeasureTheory.mlconvolution f 0 μ = 0 | true |
Nat.RecursiveIn.subst | Mathlib.Computability.RecursiveIn | ∀ {O O' : Set (ℕ →. ℕ)} {f : ℕ →. ℕ}, Nat.RecursiveIn O f → (∀ g ∈ O, Nat.RecursiveIn O' g) → Nat.RecursiveIn O' f | true |
_private.Mathlib.MeasureTheory.Integral.DominatedConvergence.0.MeasureTheory.IntegrableOn.continuousWithinAt_Iic_primitive_Iio._proof_1_4 | Mathlib.MeasureTheory.Integral.DominatedConvergence | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℝ → E} {a₀ : ℝ} (x : ℝ),
¬x < a₀ → ∀ a ∈ Set.Iic a₀, (if x < a₀ then f x else 0) = if x < a then f x else 0 | false |
TopCat.sigmaIsoSigma_hom_ι_assoc | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ {ι : Type v} (α : ι → TopCat) (i : ι) {Z : TopCat} (h : TopCat.of ((i : ι) × ↑(α i)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι α i)
(CategoryTheory.CategoryStruct.comp (TopCat.sigmaIsoSigma α).hom h) =
CategoryTheory.CategoryStruct.comp (TopCat.sigmaι α i) h | true |
CategoryTheory.Limits.biproduct.ι | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(f : J → C) → [inst_2 : CategoryTheory.Limits.HasBiproduct f] → (b : J) → f b ⟶ ⨁ f | true |
lTensor.inverse_of_rightInverse._proof_8 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N] (Q : Type u_3)
[inst_3 : AddCommGroup Q] [inst_4 : Module R Q], SMulCommClass R R (TensorProduct R Q N) | false |
Real.sqrtTwoAddSeries.eq_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), x.sqrtTwoAddSeries n.succ = √(2 + x.sqrtTwoAddSeries n) | true |
VectorField.lieBracket_fmul_left | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {V W : E → E} {x : E} {f : E → 𝕜},
DifferentiableAt 𝕜 f x →
DifferentiableAt 𝕜 V x →
VectorField.lieBracket 𝕜 (fun y => f y • V y) W x =
-(fderiv 𝕜 f x) (W x) • V x... | true |
_private.Mathlib.Order.Heyting.Basic.0.compl_sup_distrib._simp_1_1 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), aᶜ = a ⇨ ⊥ | false |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.eq_empty_iff_forall_eq._simp_1_2 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String} {p q : s.toSlice.Pos}, (String.Pos.ofToSlice p = String.Pos.ofToSlice q) = (p = q) | false |
Lean.SubExpr.Pos.isRoot | Lean.SubExpr | Lean.SubExpr.Pos → Bool | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.toList_roc_add_right_eq_map._simp_1_2 | Init.Data.Range.Polymorphic.IntLemmas | ∀ (a b c : ℤ), a + (b + c) = a + b + c | false |
CategoryTheory.Pseudofunctor.CoGrothendieck.Hom.ext_iff | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} {a b : F.CoGrothendieck}
(f g : a ⟶ b),
f = g ↔ ∃ (hfg : f.base = g.base), f.fiber = CategoryTheory.CategoryStruct.comp g.fiber (CategoryTheory.eqToHom ⋯) | true |
Lean.Elab.Tactic.Do.instBEqUses.beq | Lean.Elab.Tactic.Do.LetElim | Lean.Elab.Tactic.Do.Uses → Lean.Elab.Tactic.Do.Uses → Bool | true |
Lean.Server.Watchdog.ImportData.eraseImportsOf | Lean.Server.Watchdog | Lean.Server.Watchdog.ImportData → Lean.Lsp.DocumentUri → Lean.Server.Watchdog.ImportData | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.chainsMap_f_map_mono._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {R : Type u} [inst : Ring R] {X Y : ModuleCat R} (f : X ⟶ Y),
CategoryTheory.Mono f = Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | false |
Lean.MetavarContext.LevelMVarToParam.Context.mk.injEq | Lean.MetavarContext | ∀ (paramNamePrefix : Lean.Name) (alreadyUsedPred : Lean.Name → Bool) (except : Lean.LMVarId → Bool)
(paramNamePrefix_1 : Lean.Name) (alreadyUsedPred_1 : Lean.Name → Bool) (except_1 : Lean.LMVarId → Bool),
({ paramNamePrefix := paramNamePrefix, alreadyUsedPred := alreadyUsedPred, except := except } =
{ paramNa... | true |
Set.subsingleton_zero_smul_set | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] (s : Set β),
(0 • s).Subsingleton | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks.0.CategoryTheory.Limits.spanOp.match_1.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ (motive : CategoryTheory.Limits.WalkingSpan → Sort u_1) (h_1 : Unit → motive none)
(h_2 : Unit → motive (some CategoryTheory.Limits.WalkingPair.left))
(h_3 : Unit → motive (some CategoryTheory.Limits.WalkingPair.right)),
(match none with
| none => h_1 ()
| some CategoryTheory.Limits.WalkingPair.left => ... | true |
Lean.Lsp.TextDocumentSyncOptions.mk.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{openClose : Bool} →
{change : Lean.Lsp.TextDocumentSyncKind} →
{willSave willSaveWaitUntil : Bool} →
{save? : Option Lean.Lsp.SaveOptions} →
{openClose' : Bool} →
{change' : Lean.Lsp.TextDocumentSyncKind} →
{willSave' willSaveWaitUntil' : Bool} →
... | false |
CategoryTheory.Abelian.SpectralObject.liftCycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
(X : CategoryTheory.Abelian.SpectralObject C ι) →
{i j k : ι} →
(f : i ⟶ j) →
... | true |
CategoryTheory.Functor.mapHomotopyEquiv._proof_4 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {W : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} W]
[inst_3 : CategoryTheory.Preadditive W] (F : CategoryTheory.Functor V W) [inst_4 : ... | false |
_private.Init.Data.Array.Range.0.Array.ofFn.eq_1 | Init.Data.Array.Range | ∀ {α : Type u} {n : ℕ} (f : Fin n → α), Array.ofFn f = Array.ofFn.go✝ f (Array.emptyWithCapacity n) n ⋯ | true |
Std.DTreeMap.Internal.Impl.link2!._unary._proof_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β) (szl : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β) (h : l = Std.DTreeMap.Internal.Impl.inner szl k' v' l' r')
(r : Std.DTreeMap.Internal.Impl α β) (szr : ℕ) (k'' : α) (v'' : β k'') (l'' r'' : Std.DTreeMap.Internal.Impl α β... | false |
AddMonoidAlgebra.lift_apply' | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : AddMonoid M] [inst_2 : Semiring A]
[inst_3 : Algebra R A] (F : Multiplicative M →* A) (f : AddMonoidAlgebra R M),
((AddMonoidAlgebra.lift R A M) F) f = Finsupp.sum f fun a b => (algebraMap R A) b * F (Multiplicative.ofAdd a) | true |
CategoryTheory.Join.Hom.eq_1 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(x_2 y : C), (CategoryTheory.Join.left x_2).Hom (CategoryTheory.Join.left y) = ULift.{v₂, v₁} (x_2 ⟶ y) | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushAllArgs._sparseCasesOn_1 | Lean.Meta.Sym.Simp.DiscrTree | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
UInt32.instLawfulHasSize_2 | Init.Data.Range.Polymorphic.UInt | Std.Rxi.LawfulHasSize UInt32 | true |
FinBoolAlg.largeCategory._proof_7 | Mathlib.Order.Category.FinBoolAlg | autoParam
(∀ {X Y : FinBoolAlg} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f)
CategoryTheory.Category.id_comp._autoParam | false |
WeierstrassCurve.Projective.negDblY_of_Z_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} [inst_1 : DecidableEq F] {P Q : Fin 3 → F},
W.Equation P →
W.Equation Q →
P 2 ≠ 0 →
Q 2 ≠ 0 →
P 0 * Q 2 = Q 0 * P 2 →
P 1 * Q 2 ≠ W.negY Q * P 2 →
W.negDblY P / W.dblZ P =
W.toAffi... | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord.0.NumberField.mixedEmbedding.volume_eq_two_pi_pow_mul_integral._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_3} [inst : Zero M] {s : Set α} (f : β → α) {g : α → M} {x : β},
s.indicator g (f x) = (f ⁻¹' s).indicator (g ∘ f) x | false |
Submonoid.op_sSup | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] (S : Set (Submonoid M)), (sSup S).op = sSup (Submonoid.unop ⁻¹' S) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.