name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Set.infs_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] (s t u : Set α), s ⊼ t ⊼ u = s ⊼ (t ⊼ u) | true |
Filter.cocardinal_aleph0_eq_cofinite | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u}, Filter.cocardinal α Cardinal.isRegular_aleph0 = Filter.cofinite | true |
Sbtw.left_ne_right | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y z : P}, Sbtw R x y z → x ≠ z | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.instFaithfulSMulSubtypeMemSubalgebraSubalgebra._proof_1 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B),
FaithfulSMul (↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)) A | false |
CategoryTheory.Under.mapCongr._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} T] {X Y : T} (f g : X ⟶ Y),
f = g → ∀ (A : CategoryTheory.Under Y), (CategoryTheory.Under.map f).obj A = (CategoryTheory.Under.map g).obj A | false |
PresheafOfModules.instModuleCarrierStalkCommRingCatCarrierAbPresheafOpensCarrier._proof_1 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {X : TopCat} {R : TopCat.Presheaf CommRingCat X}
(M : PresheafOfModules (CategoryTheory.Functor.comp R (CategoryTheory.forget₂ CommRingCat RingCat))) (x : ↑X)
{i j : (TopologicalSpace.OpenNhds x)ᵒᵖ} (f : i ⟶ j)
(r :
↑(((TopologicalSpace.OpenNhds.inclusion x).op.comp
(CategoryTheory.Functor.comp ... | false |
_private.Mathlib.MeasureTheory.Measure.Hausdorff.0.Isometry.hausdorffMeasure_image._simp_1_2 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] (m : ENNReal → ENNReal),
⇑(MeasureTheory.Measure.mkMetric m) = ⇑(MeasureTheory.OuterMeasure.mkMetric m) | false |
instLawfulMonadTacticM_batteries | Batteries.Lean.LawfulMonad | LawfulMonad Lean.Elab.Tactic.TacticM | true |
TopologicalSpace.Opens.map_comp_obj' | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : Set ↑Z) (p : IsOpen U),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp f g)).obj { carrier := U, is_open' := p } =
(TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj { carrier := U, is_open' := p }) | true |
CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft_base | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | true |
BitVec.extractLsb'_append_eq_of_le | Init.Data.BitVec.Lemmas | ∀ {v w : ℕ} {xhi : BitVec v} {xlo : BitVec w} {start len : ℕ},
w ≤ start → BitVec.extractLsb' start len (xhi ++ xlo) = BitVec.extractLsb' (start - w) len xhi | true |
CategoryTheory.CostructuredArrow.isSeparating_proj_preimage | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(S : CategoryTheory.Functor C D) (T : D) {P : CategoryTheory.ObjectProperty C},
P.IsSeparating → (P.inverseImage (CategoryTheory.CostructuredArrow.proj S T)).IsSeparating | true |
UInt16.toUSize_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a <<< b).toUSize = a.toUSize <<< (b % 16).toUSize % 65536 | true |
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.union_ae_eq_right._simp_1_2 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, (s ≤ᵐ[μ] t) = (μ (s \ t) = 0) | false |
Function.Even | Mathlib.Algebra.Group.EvenFunction | {α : Type u_1} → {β : Type u_2} → [Neg α] → (α → β) → Prop | true |
Mathlib.Meta.NormNum.IsNNRat.to_isRat | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : Ring α] {a : α} {n d : ℕ},
Mathlib.Meta.NormNum.IsNNRat a n d → Mathlib.Meta.NormNum.IsRat a (Int.ofNat n) d | true |
Lean.Lsp.VersionedTextDocumentIdentifier.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.VersionedTextDocumentIdentifier → Sort u} →
(t : Lean.Lsp.VersionedTextDocumentIdentifier) →
((uri : Lean.Lsp.DocumentUri) → (version? : Option ℕ) → motive { uri := uri, version? := version? }) → motive t | false |
Nat.stirlingSecond._sunfold | Mathlib.Combinatorics.Enumerative.Stirling | ℕ → ℕ → ℕ | false |
smoothPresheafCommGroup._proof_2 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | false |
AffineIsometryEquiv.toAffineIsometry | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
{P : Type u_10} →
{P₂ : Type u_11} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : Nor... | true |
Lean.Elab.Tactic.withCaseRef | Lean.Elab.Tactic.Basic | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.MonadRef m] → Lean.Syntax → Lean.Syntax → m α → m α | true |
CStarMatrix.mapₗ | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
{S : Type u_4} →
{A : Type u_5} →
{B : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
[inst_2 : AddCommMonoid A] →
[inst_3 : AddComm... | true |
HasLineDerivWithinAt.mono | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f' : F}
{s t : Set E} {x v : E}, HasLineDerivWithinAt 𝕜 f f' s x v → t ⊆ s → HasLineDerivWithinAt 𝕜 f f' t x... | true |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk.sizeOf_spec | Lean.Server.ProtocolOverview | ∀ (method : String) (direction : Lean.JsonRpc.MessageDirection)
(kinds : Array Lean.Server.Overview.ProtocolExtensionKind✝) (parameterType : Type) (description : String),
sizeOf
{ method := method, direction := direction, kinds := kinds, parameterType := parameterType,
description := description } =
... | true |
LinearMap.equivOfDetNeZero._proof_3 | Mathlib.LinearAlgebra.Determinant | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module 𝕜 M], SMulCommClass 𝕜 𝕜 M | false |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.mk.injEq | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | ∀ (varMap : Lean.Meta.KExprMap ℕ) (vars : Array Lean.Expr) (varMap_1 : Lean.Meta.KExprMap ℕ) (vars_1 : Array Lean.Expr),
({ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 }) = (varMap = varMap_1 ∧ vars = vars_1) | true |
Equiv.subtypeSubtypeEquivSubtype_apply_coe | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} {p q : α → Prop} (h : ∀ {x : α}, q x → p x) (a : { x // q ↑x }),
↑((Equiv.subtypeSubtypeEquivSubtype h) a) = ↑↑a | true |
Subtype.val_prop | Mathlib.Data.Subtype | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), ↑a ∈ S | true |
CategoryTheory.ObjectProperty.productToFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.StructuredArrow X P.ι → C | true |
SubMulAction.ofStabilizer.conjMap | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | {G : Type u_1} →
[inst : Group G] →
{α : Type u_2} →
[inst_1 : MulAction G α] →
{g : G} →
{a b : α} →
(hg : b = g • a) →
↥(SubMulAction.ofStabilizer G a) →ₑ[⇑(MulAction.stabilizerEquivStabilizer hg)]
↥(SubMulAction.ofStabilizer G b) | true |
_private.Mathlib.RingTheory.Ideal.Lattice.0.Ideal.eq_top_of_isUnit_mem.match_1_1 | Mathlib.RingTheory.Ideal.Lattice | ∀ {α : Type u_1} [inst : Semiring α] {x : α} (motive : (∃ b, b * x = 1) → Prop) (x_1 : ∃ b, b * x = 1),
(∀ (y : α) (hy : y * x = 1), motive ⋯) → motive x_1 | false |
CategoryTheory.Bicategory.rightAdjointSquareConjugate.vcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : B} →
{g : a ⟶ c} →
{h : b ⟶ d} →
{r₁ : b ⟶ a} →
{r₂ r₃ : d ⟶ c} →
(CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.CategoryStruct.comp h r₂) →
(r₂ ⟶ r₃) → (CategoryTheory.Cat... | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_coe_sort._simp_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u}, Nontrivial α = Set.univ.Nontrivial | false |
Filter.filter_eq_iff | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f g : Filter α}, f = g ↔ f.sets = g.sets | true |
Hyperreal.archimedeanClassMk_nonneg_of_tendsto | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*} {r : ℝ}, Filter.Germ.Tendsto x (nhds r) → 0 ≤ ArchimedeanClass.mk x | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_mem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed sᶜ = IsOpen s | false |
ProbabilityTheory.Kernel.eq_rnDeriv_measure | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η ξ : ProbabilityTheory.Kernel α γ}
{f : α → γ → ENNReal} [inst : ProbabilityTheory.IsFiniteKernel η],
κ = η.withDensity f + ξ →
Measurable (Function.uncurry f) → ∀ (a : α), (ξ a).MutuallySingular (η a) → f a =ᵐ[η a] (κ a).rnDe... | true |
Multiset.cons_lt_cons_iff._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s t : Multiset α} {a : α}, (a ::ₘ s < a ::ₘ t) = (s < t) | false |
SemilatInfCat.hasForgetToPartOrd._proof_2 | Mathlib.Order.Category.Semilat | ∀ {X Y Z : SemilatInfCat} (f : X ⟶ Y) (g : Y ⟶ Z),
PartOrd.ofHom { toFun := ⇑(CategoryTheory.CategoryStruct.comp f g).toInfHom, monotone' := ⋯ } =
CategoryTheory.CategoryStruct.comp (PartOrd.ofHom { toFun := ⇑f.toInfHom, monotone' := ⋯ })
(PartOrd.ofHom { toFun := ⇑g.toInfHom, monotone' := ⋯ }) | false |
CommMonCat.coyonedaType._proof_4 | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : Type u_1ᵒᵖ),
{
app := fun N =>
CommMonCat.ofHom
(Pi.monoidHom fun i => Pi.evalMonoidHom (fun a => ↑N) ((CategoryTheory.CategoryStruct.id X).unop i)),
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id
{ obj := fun M => CommMonCat.of (Opposite.unop X → ↑M),
map ... | false |
Subgroup._sizeOf_inst | Mathlib.Algebra.Group.Subgroup.Defs | (G : Type u_3) → {inst : Group G} → [SizeOf G] → SizeOf (Subgroup G) | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_A_with_param._simp_1_3 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | false |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.succ_signVariations_le_X_sub_C_mul._proof_1_8 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] {η : R} {P : Polynomial R} (d : ℕ),
(∀ m < d + 1,
∀ {P : Polynomial R},
P ≠ 0 → P.natDegree = m → P.signVariations + 1 ≤ ((Polynomial.X - Polynomial.C η) * P).signVariations) →
P.eraseLead.natDegree < d + 1 →
¬P.eraseLead = 0 →
... | false |
Ordinal.cof_le_card | Mathlib.SetTheory.Cardinal.Cofinality | ∀ (o : Ordinal.{u_1}), o.cof ≤ o.card | true |
BitVec.clzAuxRec_eq_clzAuxRec_of_le | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} {x : BitVec w}, w - 1 ≤ n → x.clzAuxRec n = x.clzAuxRec (w - 1) | true |
ModuleCat.rec | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} →
[inst : Ring R] →
{motive : ModuleCat R → Sort u_1} →
((carrier : Type v) →
[isAddCommGroup : AddCommGroup carrier] →
[isModule : Module R carrier] →
motive { carrier := carrier, isAddCommGroup := isAddCommGroup, isModule := isModule }) →
(t : Modul... | false |
Filter.tendsto_atTop_pure | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : PartialOrder α] [inst_1 : OrderTop α] (f : α → β),
Filter.Tendsto f Filter.atTop (pure (f ⊤)) | true |
Lean.Meta.Match.Example.var | Lean.Meta.Match.Basic | Lean.FVarId → Lean.Meta.Match.Example | true |
GradedTensorProduct.lift._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} [inst : CommRing R] {C : Type u_2} [inst_1 : Ring C] [inst_2 : Algebra R C], SMulCommClass R C C | false |
_private.Std.Time.Zoned.Offset.0.Std.Time.TimeZone.instDecidableEqOffset.decEq._proof_2 | Std.Time.Zoned.Offset | ∀ (a b : Std.Time.Second.Offset), ¬a = b → { second := a } = { second := b } → False | false |
Lean.Meta.DSimp.Config.decide | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool | true |
hasProd_unique._simp_2 | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Unique β] (f : β → α)
(L : optParam (SummationFilter β) (SummationFilter.unconditional β)) [L.LeAtTop], HasProd f (f default) L = True | false |
Bundle.Trivialization.prod.eq_1 | Mathlib.Topology.VectorBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] {F₁ : Type u_2} [inst_1 : TopologicalSpace F₁] {E₁ : B → Type u_3}
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [inst_3 : TopologicalSpace F₂]
{E₂ : B → Type u_5} [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
(e₁ : Bundle.Trivialization... | true |
CategoryTheory.Comma.mapLeftComp_hom_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ L₃ : CategoryTheory.Functor A T} (l : L₁ ⟶ L₂) (l' : L₂ ⟶ L₃) (X : CategoryTheory.Comma L₃ R),
... | true |
HNNExtension.NormalWord.instMulAction | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} → {d : HNNExtension.NormalWord.TransversalPair G A B} → MulAction G (HNNExtension.NormalWord d) | true |
CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair_hom_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
(x : CategoryTheory.Limits.WalkingReflexivePair),
(CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair F).hom.app x =
match x with
| CategoryTheory.Limits.WalkingRefle... | true |
Topology.IsEmbedding.prodMap | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : X → Y} {g : Z → W},
Topology.IsEmbedding f → Topology.IsEmbedding g → Topology.IsEmbedding (Prod.map f g) | true |
Std.DTreeMap.Internal.Impl.maxEntry?.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.Intern... | false |
HasFDerivWithinAt.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}
{f' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt f f' s x → ∀ (c : F), HasFDerivWithinAt (... | true |
Std.DHashMap.Raw.Equiv.size_eq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁.size = m₂.size | true |
CoxeterSystem.mk.noConfusion | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} →
{M : CoxeterMatrix B} →
{W : Type u_2} →
{inst : Group W} →
{P : Sort u} →
{mulEquiv mulEquiv' : W ≃* M.Group} →
{ mulEquiv := mulEquiv } = { mulEquiv := mulEquiv' } → (mulEquiv ≍ mulEquiv' → P) → P | false |
CategoryTheory.Classifier.mono_truth._autoParam | Mathlib.CategoryTheory.Topos.Classifier | Lean.Syntax | false |
Submonoid.isScalarTower | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MulOneClass M'] [inst_1 : SMul α β] [inst_2 : SMul M' α]
[inst_3 : SMul M' β] [IsScalarTower M' α β] (S : Submonoid M'), IsScalarTower (↥S) α β | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.instDecidableEqLiteral.decEq._proof_3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | ∀ (a : ℕ) (a_1 : BitVec a) (b : ℕ) (b_1 : BitVec b),
¬a = b → { n := a, value := a_1 } = { n := b, value := b_1 } → False | false |
Lean.Lsp.DeleteFile.Options.ignoreIfNotExists | Lean.Data.Lsp.Basic | Lean.Lsp.DeleteFile.Options → Bool | true |
LieAlgebra.IsEngelian._proof_2 | Mathlib.Algebra.Lie.Engel | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | false |
Rat.mk'_pow._proof_2 | Mathlib.Data.Rat.Defs | ∀ (den : ℕ), den ≠ 0 → ∀ (n : ℕ), den ^ n ≠ 0 | false |
_private.Mathlib.Algebra.Lie.OfAssociative.0.termφ | Mathlib.Algebra.Lie.OfAssociative | Lean.ParserDescr | true |
Mathlib.Tactic.Conv.Path.rec | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} →
((arg : ℕ) →
(all : Bool) →
(next : Mathlib.Tactic.Conv.Path) → motive next → motive (Mathlib.Tactic.Conv.Path.arg arg all next)) →
((depth : ℕ) → motive (Mathlib.Tactic.Conv.Path.fun depth)) →
((next : Mathlib.Tactic.Conv.Path) → motive next → mo... | false |
List.pmap.eq_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) (x_2 : ∀ a ∈ [], P a), List.pmap f [] x_2 = [] | true |
Int64.instLawfulOrderOrd | Init.Data.Ord.SInt | Std.LawfulOrderOrd Int64 | true |
EuclideanGeometry.Sphere.orthRadius_eq_orthRadius_iff._simp_1 | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p q : P}, (s.orthRadius p = s.orthRadius q) = (p = q) | false |
Lean.Meta.SizeOfSpecNested.Context.recOn | Lean.Meta.SizeOf | {motive : Lean.Meta.SizeOfSpecNested.Context → Sort u} →
(t : Lean.Meta.SizeOfSpecNested.Context) →
((indInfo : Lean.InductiveVal) →
(sizeOfFns : Array Lean.Name) →
(ctorName : Lean.Name) →
(params localInsts : Array Lean.Expr) →
(recMap : Lean.NameMap Lean.Name) →
... | false |
Pi.algebraMap._proof_2 | Mathlib.Algebra.Algebra.Pi | ∀ (ι : Type u_1) (R : Type u_3) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(t : R) (v : ι → R), ⇑(algebraMap R A) ∘ (t • v) = (RingHom.id R) t • ⇑(algebraMap R A) ∘ v | false |
Lean.Grind.CommRing.Poly.denote_insert | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Ring α] (ctx : Lean.Grind.CommRing.Context α) (k : ℤ) (m : Lean.Grind.CommRing.Mon)
(p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.insert k m p) =
↑k * Lean.Grind.CommRing.Mon.denote ctx m + Lean.Grind.CommRing.Poly.denote ctx p | true |
DyckStep.D | Mathlib.Combinatorics.Enumerative.DyckWord | DyckStep | true |
ProbabilityTheory.gaussianPDF_def | Mathlib.Probability.Distributions.Gaussian.Real | ∀ (μ : ℝ) (v : NNReal),
ProbabilityTheory.gaussianPDF μ v = fun x => ENNReal.ofReal (ProbabilityTheory.gaussianPDFReal μ v x) | true |
ContinuousOn.strictAntiOn_of_injOn_Icc | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
a ≤ b → f b ≤ f a → ContinuousOn f (Set.Icc a b) → Set.InjOn f (Set.Icc... | true |
Ideal.idealProdEquiv.match_1 | Mathlib.RingTheory.Ideal.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (motive : Ideal R × Ideal S → Prop)
(x : Ideal R × Ideal S), (∀ (I : Ideal R) (J : Ideal S), motive (I, J)) → motive x | false |
Mathlib.Tactic.Abel.abelNFConv | Mathlib.Tactic.Abel | Lean.ParserDescr | true |
_private.Lean.CoreM.0.Lean.Core.wrapAsync.match_3 | Lean.CoreM | (motive : Lean.NameGenerator × Lean.NameGenerator → Sort u_1) →
(x : Lean.NameGenerator × Lean.NameGenerator) →
((childNGen parentNGen : Lean.NameGenerator) → motive (childNGen, parentNGen)) → motive x | false |
CategoryTheory.CatCenter.smul_iso_hom_eq | Mathlib.CategoryTheory.Center.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (z : (CategoryTheory.CatCenter C)ˣ) {X Y : C} (f : X ≅ Y),
(z • f).hom = CategoryTheory.CategoryStruct.comp f.hom ((↑z).app Y) | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
-2 ^ (w + 1) ≤ 2 * x.toInt →
2 * x.toInt < 2 ^ (w + 1) →
-2 ^ (w + 1) ≤ 2 * y.toInt →
2 * y.toInt < 2 ^ (w + 1) →
(-2 ^ (w + 1) ≤ x.toInt - y.toInt →
x.toInt - y.toInt < 2 ^ (w + 1) →
((x.toInt - y.toInt).bmod (2 ^ (w + 1)) < ... | false |
Int.Linear.Expr.var.injEq | Init.Data.Int.Linear | ∀ (i i_1 : Int.Linear.Var), (Int.Linear.Expr.var i = Int.Linear.Expr.var i_1) = (i = i_1) | true |
CategoryTheory.Abelian.comp_epiDesc | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[inst_2 : CategoryTheory.Epi f] {T : C} (g : X ⟶ T)
(hg : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) g = 0),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Abelian.ep... | true |
Algebra.intTraceAux | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | (A : Type u_1) →
(K : Type u_2) →
(L : Type u_3) →
(B : Type u_6) →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
[inst_3 : Field K] →
[inst_4 : Field L] →
[inst_5 : Algebra A K] →
[IsF... | true |
LinearEquiv.isUnit_det' | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M] (f : M ≃ₗ[A] M),
IsUnit (LinearMap.det ↑f) | true |
BoxIntegral.Prepartition.filter | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} →
{I : BoxIntegral.Box ι} → BoxIntegral.Prepartition I → (BoxIntegral.Box ι → Prop) → BoxIntegral.Prepartition I | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
↑(2 ^ w) ≤ x.toInt - y.toInt → ¬-(↑(2 ^ (w + 1)) / 2) ≤ x.toInt - y.toInt - ↑(2 ^ (w + 1)) → False | false |
bddAbove_iff_exists_ge | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeSup γ] {s : Set γ} (x₀ : γ), BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x | true |
PowerSeries.derivativeFun | Mathlib.RingTheory.PowerSeries.Derivative | {R : Type u_1} → [CommSemiring R] → PowerSeries R → PowerSeries R | true |
Std.LinearOrderPackage.ctorIdx | Init.Data.Order.PackageFactories | {α : Type u} → Std.LinearOrderPackage α → ℕ | false |
CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f g] {Z_1 : C}
(h : Opposite.unop (CategoryTheory.Limits.pullback f.op g.op) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr f g)
(Category... | true |
EuclideanGeometry.Sphere.dist_div_cos_oangle_center_eq_two_mul_radius | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_3} {P : Type u_4} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → p₂ ∈ s → p₁ ≠ p₂ → dist p₁ p₂ /... | true |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C (CategoryTheory.Mon D)} (α : X ⟶ Y),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one { app := fun ... | false |
FreeAddMagma | Mathlib.Algebra.Free | Type u → Type u | true |
CategoryTheory.PreOneHypercover.sieve₁_inter | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] {i j : E.I₀ × F.I₀} {W : C}
{p₁ : W ⟶ CategoryTheory.Limits.pullback (E.f i.1) (F.f i.2)}
{p₂ : W ⟶ CategoryTheory.Limits... | true |
Module.Basis.mk._proof_1 | Mathlib.LinearAlgebra.Basis.Basic | ∀ {R : Type u_1} [inst : Semiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
_private.Lean.Meta.Tactic.Grind.Ctor.0.Lean.Meta.Grind.propagateCtorHetero._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Ctor | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
iInf_ite | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] (p : ι → Prop) [inst_1 : DecidablePred p] (f g : ι → α),
(⨅ i, if p i then f i else g i) = (⨅ i, ⨅ (_ : p i), f i) ⊓ ⨅ i, ⨅ (_ : ¬p i), g i | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.