name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Aesop.CasesTarget.patterns | Aesop.RuleTac.Basic | Array Aesop.CasesPattern → Aesop.CasesTarget | null | true |
Lean.Parser.Command.tactic_extension | Lean.Parser.Command | Lean.Parser.Parser | Adds more documentation as an extension of the documentation for a given tactic.
The extended documentation is placed in the command's docstring. It is shown as part of a bulleted
list, so it should be brief.
| true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0.Fin.reduceOfNat._regBuiltin.Fin.reduceOfNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.2648448030._hygCtx._hyg.23 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | null | false |
Stream'.Seq.zipWith_map_right | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {β' : Type v'} (s₁ : Stream'.Seq α) (s₂ : Stream'.Seq β) (f : β → β')
(g : α → β' → γ), Stream'.Seq.zipWith g s₁ (Stream'.Seq.map f s₂) = Stream'.Seq.zipWith (fun a b => g a (f b)) s₁ s₂ | null | true |
_private.Init.Data.List.Erase.0.List.filterMap.match_1.eq_1 | Init.Data.List.Erase | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | null | true |
LinearMap.tracePositiveLinearMap._proof_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
SMulCommClass 𝕜 𝕜 E | null | false |
Lean.Meta.Sym.ProofInstArgInfo.noConfusion | Lean.Meta.Sym.SymM | {P : Sort u} → {t t' : Lean.Meta.Sym.ProofInstArgInfo} → t = t' → Lean.Meta.Sym.ProofInstArgInfo.noConfusionType P t t' | null | false |
OrderIso.dualAntisymmetrization._proof_6 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a : (Antisymmetrization α fun x1 x2 => x1 ≤ x2)ᵒᵈ),
Quotient.map' id ⋯ (Quotient.map' id ⋯ a) = a | null | false |
MaxTropical.add_eq_right | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LinearOrder R] ⦃x y : MaxTropical R⦄, x ≤ y → x + y = y | null | true |
RingHom.ENatMap._proof_1 | Mathlib.Data.ENat.Monoid | ∀ {S : Type u_1} [inst : CommSemiring S] [inst_1 : PartialOrder S] [CanonicallyOrderedAdd S], Subsingleton (AddUnits S) | null | false |
CompactExhaustion.iUnion_eq | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X), ⋃ n, K n = Set.univ | null | true |
SimpleGraph.Walk.getVert_eq_support_getElem? | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {n : ℕ} (p : G.Walk u v), n ≤ p.length → some (p.getVert n) = p.support[n]? | null | true |
Lean.Meta.Sym.DSimp.Config.instances | Lean.Meta.Sym.DSimp.DSimpM | Lean.Meta.Sym.DSimp.Config → Bool | If `instances` is `true`, `dsimp` will visit instance arguments.
This is set to `false` by default as simplifying in instances is usually not meaningful and we
want to avoid producing non-standard instances. However, in certain situations simplifying in
instances can aid with making more terms syntactically equal.
| true |
Metric.ediam_pos_iff' | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : TopologicalSpace X] [inst_1 : WeakEMetricSpace X],
0 < Metric.ediam s ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y | null | true |
Std.ExtDHashMap.get?_eq_none_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {a : α},
m.contains a = false → m.get? a = none | null | true |
Function.diag_def | Mathlib.Logic.Function.Defs | ∀ {α : Type u_1}, Function.diag = fun a => (a, a) | null | true |
Pi.distrib | Mathlib.Algebra.Ring.Pi | {I : Type u} → {f : I → Type v} → [(i : I) → Distrib (f i)] → Distrib ((i : I) → f i) | null | true |
Subsemiring.mem_unop | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {x : R} {S : Subsemiring Rᵐᵒᵖ}, x ∈ S.unop ↔ MulOpposite.op x ∈ S | null | true |
LieAlgebra.Extension.casesOn | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{N : Type u_2} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing N] →
[inst_2 : LieAlgebra R N] →
[inst_3 : LieRing M] →
[inst_4 : LieAlgebra R M] →
{motive : LieAlgebra.Extension R N M → Sort u} →
(t : L... | null | false |
SSet.Truncated.HomotopyCategory.homToNerveMk_app_edge | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X : SSet.Truncated 2} {C : Type u} [inst : CategoryTheory.SmallCategory C]
(F : CategoryTheory.Functor X.HomotopyCategory C)
{x y : X.obj (Opposite.op { obj := { len := 0 }, property := _proof_12✝ })} (e : SSet.Truncated.Edge x y),
(CategoryTheory.ConcreteCategory.hom
((SSet.Truncated.HomotopyCategory.... | null | true |
PFunctor.M.IsPath.cons | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (xs : PFunctor.Approx.Path F) {a : F.A} (x : F.M) (f : F.B a → F.M) (i : F.B a),
x = PFunctor.M.mk (PFunctor.Obj.mk a f) → PFunctor.M.IsPath xs (f i) → PFunctor.M.IsPath (⟨a, i⟩ :: xs) x | null | true |
Std.ExtDHashMap.Const.size_alter_le_size | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β}, (Std.ExtDHashMap.Const.alter m k f).size ≤ m.size + 1 | null | true |
RingEquiv.map_sub | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R ≃+* S)
(x y : R), f (x - y) = f x - f y | null | true |
Std.Internal.List.getKey?_filter_containsKey_of_containsKey_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getKey? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) =
Std.Internal.List.getKe... | null | true |
HomotopicalAlgebra.Precylinder.LeftHomotopy.refl._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (P : HomotopicalAlgebra.Precylinder X) {Y : C}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp P.i₀ (CategoryTheory.CategoryStruct.comp P.π f) = f | null | false |
Std.Async.Selector.casesOn | Std.Async.Select | {α : Type} →
{motive : Std.Async.Selector α → Sort u} →
(t : Std.Async.Selector α) →
((tryFn : Std.Async.Async (Option α)) →
(registerFn : Std.Async.Waiter α → Std.Async.Async Unit) →
(unregisterFn : Std.Async.Async Unit) →
motive { tryFn := tryFn, registerFn := registerF... | null | false |
CategoryTheory.yoneda_preservesLimits | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} (CategoryTheory.yoneda.obj X) | The yoneda embedding `yoneda.obj X : Cᵒᵖ ⥤ Type v` for `X : C` preserves limits. | true |
ZFSet.mem_pairSep._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {p : ZFSet.{u} → ZFSet.{u} → Prop} {x y z : ZFSet.{u}},
(z ∈ ZFSet.pairSep p x y) = ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b | null | false |
Finpartition.mem_part_self | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) {a : α}, a ∈ P.part a ↔ a ∈ s | null | true |
AddUnits.recOn | Mathlib.Algebra.Group.Units.Defs | {α : Type u} →
[inst : AddMonoid α] →
{motive : AddUnits α → Sort u_1} →
(t : AddUnits α) →
((val neg : α) →
(val_neg : val + neg = 0) →
(neg_val : neg + val = 0) → motive { val := val, neg := neg, val_neg := val_neg, neg_val := neg_val }) →
motive t | null | false |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_3 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | Lean.Syntax | null | false |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Filter.totallyBounded_iSup._simp_1_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {s : Set α} {f : Filter α}, (s ∈ f) = (f ≤ Filter.principal s) | null | false |
Homeomorph.sumArrowHomeomorphProdArrow._proof_4 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : Type u_2} {ι' : Type u_3} (i : ι),
Continuous fun a => (Equiv.sumArrowEquivProdArrow ι ι' X).invFun a (Sum.inl i) | null | false |
CategoryTheory.Functor.ext_of_iso | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (e : F ≅ G) (hobj : ∀ (X : C), F.obj X = G.obj X),
autoParam (∀ (X : C), e.hom.app X = CategoryTheory.eqToHom ⋯) CategoryTheory.Functor.ext_of_iso._auto_1 → F = ... | null | true |
CategoryTheory.ReflQuiv.isoOfQuivIso._proof_1 | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {V W : Type u_2} [inst : CategoryTheory.ReflQuiver V] [inst_1 : CategoryTheory.ReflQuiver W] (e : ↧V ≅ ↧W),
(∀ (X : V), e.hom.map (CategoryTheory.ReflQuiver.id X) = CategoryTheory.ReflQuiver.id (e.hom.obj X)) →
∀ (Y : ↑↧W),
(CategoryTheory.Quiv.homEquivOfIso e) (e.inv.map (CategoryTheory.ReflQuiver.id Y))... | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.subset_union_prime._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
MeasureTheory.OuterMeasure.comap_iInf | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} {ι : Sort u_2} {β : Type u_3} (f : α → β) (m : ι → MeasureTheory.OuterMeasure β),
(MeasureTheory.OuterMeasure.comap f) (⨅ i, m i) = ⨅ i, (MeasureTheory.OuterMeasure.comap f) (m i) | null | true |
Configuration.HasLines.toNondegenerate | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.HasLines P L],
Configuration.Nondegenerate P L | null | true |
CategoryTheory.uliftCategory._proof_4 | Mathlib.CategoryTheory.Category.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C] {X Y : ULift.{u_1, u_2} C} (f : X.down ⟶ Y.down),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y.down) = f | null | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.integrable_gaussianPDFReal._simp_1_12 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
CompHausLike.LocallyConstant.counitApp.eq_1 | Mathlib.Condensed.Discrete.Colimit | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] [inst_2 : CompHausLike.HasExplicitFiniteCoproducts P]
(Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w)))
[inst_3 : CategoryTheory.Limits.Pre... | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.synthesizeInstMVarCore._sparseCasesOn_4 | Lean.Elab.Term.TermElabM | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
PolynomialLaw.instSMul | Mathlib.RingTheory.PolynomialLaw.Basic | {R : Type u} →
[inst : CommSemiring R] →
{M : Type u_1} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Type u_2} → [inst_3 : AddCommMonoid N] → [inst_4 : Module R N] → SMul R (M →ₚₗ[R] N) | null | true |
Subfield.relrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B C : Subfield E}, A ⊓ C = B ⊓ C → A.relrank C = B.relrank C | null | true |
TannakaDuality.FiniteGroup.rightFDRep._proof_1 | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u_1} [inst : CommRing k] [Finite G], Module.Finite k (G → k) | null | false |
Std.TreeMap.Equiv.maxKey_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{h' : t₁.isEmpty = false} (h : t₁.Equiv t₂), t₁.maxKey h' = t₂.maxKey ⋯ | null | true |
String.Slice.toNat?_eq_none_iff | Std.Data.String.ToNat | ∀ {s : String.Slice}, s.toNat? = none ↔ s.isNat = false | null | true |
Matrix.instLieRingToLieAlgebra._proof_27 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B]
(x y z : Matrix.ToLieAlgebra R CM), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆ | null | false |
CategoryTheory.Pretriangulated.contractibleTriangleFunctor._proof_2 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.contractibleTriangle ... | null | false |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.closure_iUnion._simp_1_3 | Mathlib.Topology.LocallyFinite | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
LowerSet.ctorIdx | Mathlib.Order.Defs.Unbundled | {α : Type u_1} → {inst : LE α} → LowerSet α → ℕ | null | false |
CategoryTheory.Limits.isLimitConeOfAdj | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{L : CategoryTheory.Functor (CategoryTheory.Functor J C) C} →
(adj : CategoryTheory.Functor.const J ⊣ L) →
(F : CategoryTheory.Functor J C) → CategoryTheor... | The cones defined by `coneOfAdj` are limit cones. | true |
Std.Internal.List.getValueCast?_filter_not_contains_of_contains_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α} {k : α},
Std.Internal.List.DistinctKeys l₁ →
l₂.contains k = false →
Std.Internal.List.getValueCast? k (List.filter (fun p => !l₂.contains p.fst) l₁) =
Std.Internal.List.getValueCast? k l₁ | null | true |
AddSubmonoid.instSetLike.eq_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M], AddSubmonoid.instSetLike = { coe := fun s => s.carrier, coe_injective := ⋯ } | null | true |
Prefunctor.symmetrify_map | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {U : Type u_1} {V : Type u_2} [inst : Quiver U] [inst_1 : Quiver V] (φ : U ⥤q V) {X Y : Quiver.Symmetrify U}
(a : (X ⟶ Y) ⊕ (Y ⟶ X)), φ.symmetrify.map a = Sum.map φ.map φ.map a | null | true |
TopologicalSpace.denseRange_denseSeq | Mathlib.Topology.Bases | ∀ (α : Type u) [t : TopologicalSpace α] [inst : TopologicalSpace.SeparableSpace α] [inst_1 : Nonempty α],
DenseRange (TopologicalSpace.denseSeq α) | The sequence `TopologicalSpace.denseSeq α` has dense range. | true |
_private.Mathlib.CategoryTheory.Sites.SheafCohomology.ExactSequences.0.CategoryTheory.Sheaf.H.longSequence_exact₂'._proof_1 | Mathlib.CategoryTheory.Sites.SheafCohomology.ExactSequences | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat],
CategoryTheory.CategoryWithHomology
(CategoryTheory.ObjectProperty.FullSubcategory (CategoryTheory.Presheaf.IsSheaf J)) | null | false |
Lean.Order.true_le_of_top_le | Std.Internal.Order.Lemmas | ∀ (x : Prop), Lean.Order.PartialOrder.rel Lean.Order.top x → Lean.Order.PartialOrder.rel True x | null | true |
ProbabilityTheory.gaussianReal_sub_const | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : Ω → ℝ},
ProbabilityTheory.HasLaw X (ProbabilityTheory.gaussianReal μ v) P →
∀ (y : ℝ), ProbabilityTheory.HasLaw (fun ω => X ω - y) (ProbabilityTheory.gaussianReal (μ - y) v) P | If `X` is a real random variable with Gaussian law with mean `μ` and variance `v`, then `X - y`
has Gaussian law with mean `μ - y` and variance `v`. | true |
CategoryTheory.Limits.WalkingMultispan.proxyType | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | CategoryTheory.Limits.MultispanShape → Type (max w w') | A "proxy type" equivalent to `CategoryTheory.Limits.WalkingMultispan` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `CategoryTheory.Limits.WalkingMultispan.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.) | true |
Set.countable_iff_exists_surjective | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Nonempty → (s.Countable ↔ ∃ f, Function.Surjective f) | A non-empty set is countable iff there exists a surjection from the
natural numbers onto the subtype induced by the set.
| true |
LocallyConstant.instAddZeroClass.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddZeroClass Y],
LocallyConstant.instAddZeroClass = Function.Injective.addZeroClass DFunLike.coe ⋯ ⋯ ⋯ | null | true |
Fin.instUpwardEnumerable | Init.Data.Range.Polymorphic.Fin | {n : ℕ} → Std.PRange.UpwardEnumerable (Fin n) | null | true |
SimpleGraph.isVertexCover_empty._simp_1 | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u_1} {G : SimpleGraph V}, G.IsVertexCover ∅ = (G = ⊥) | null | false |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.Fernique.lintegral_exp_mul_sq_norm_le_mul._simp_1_13 | Mathlib.Probability.Distributions.Fernique | ∀ {a : ENNReal}, (0 < a.toReal) = (0 < a ∧ a < ⊤) | null | false |
Mathlib.Tactic.ClickSuggestions.GrwKey.numGoals | Mathlib.Tactic.ClickSuggestions.GRewrite | Mathlib.Tactic.ClickSuggestions.GrwKey → ℕ | The number of side goals created. | true |
Aesop.instInhabitedRuleBuilderOptions | Aesop.Builder.Basic | Inhabited Aesop.RuleBuilderOptions | null | true |
LieModuleEquiv.mk._flat_ctor | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | null | false |
DFinsupp.equivFunOnFintype._proof_3 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → Zero (β i)] [inst_1 : Fintype ι] (x : Π₀ (i : ι), β i) (x_1 : ι),
x_1 ∈ Finset.univ.val ∨ x x_1 = 0 | null | false |
CategoryTheory.ShrinkHoms.comp_def | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{X Y Z : CategoryTheory.ShrinkHoms.{u} C} (f : Shrink.{w, v} (X.fromShrinkHoms ⟶ Y.fromShrinkHoms))
(g : Shrink.{w, v} (Y.fromShrinkHoms ⟶ Z.fromShrinkHoms)),
CategoryTheory.CategoryStruct.comp f g =
(e... | null | true |
ProbabilityTheory.IndepSets.union | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s₁ s₂ s' : Set (Set Ω)},
ProbabilityTheory.IndepSets s₁ s' μ → ProbabilityTheory.IndepSets s₂ s' μ → ProbabilityTheory.IndepSets (s₁ ∪ s₂) s' μ | null | true |
CategoryTheory.Limits.FormalCoproduct.eval_obj_obj | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (A : Type u₁) [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
[inst_2 : CategoryTheory.Limits.HasCoproducts A] (F : CategoryTheory.Functor C A)
(X : CategoryTheory.Limits.FormalCoproduct C),
((CategoryTheory.Limits.FormalCoproduct.eval C A).obj F).obj X = ∐ f... | null | true |
ShrinkingLemma.PartialRefinement.instCoeFunForallSet | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} → {p : Set X → Prop} → CoeFun (ShrinkingLemma.PartialRefinement u s p) fun x => ι → Set X | null | true |
Equiv.swap_apply_eq_iff | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y z w : α}, (Equiv.swap x y) z = w ↔ z = (Equiv.swap x y) w | null | true |
TopologicalSpace.Compacts.lipschitz_prod | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : EMetricSpace α] [inst_1 : EMetricSpace β], LipschitzWith 1 fun p => p.1 ×ˢ p.2 | null | true |
DirectLimit.map₀RingHom._proof_2 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
_private.Mathlib.Analysis.Convex.DoublyStochasticMatrix.0.convex_doublyStochastic._simp_1_1 | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
Mathlib.Meta.FunProp.TheoremForm.comp | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.TheoremForm | null | true |
IsAntichain.preimage_relIso | Mathlib.Order.Antichain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {t : Set β},
IsAntichain r' t → ∀ (φ : r ≃r r'), IsAntichain r (⇑φ ⁻¹' t) | null | true |
NonemptyInterval.fst_sub | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
[inst_4 : AddLeftMono α] (s t : NonemptyInterval α), (s - t).toProd.1 = s.toProd.1 - t.toProd.2 | null | true |
Set.extremePoints_eq_self | Mathlib.Analysis.Convex.Extreme | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] [Subsingleton E] (A : Set E), Set.extremePoints 𝕜 A = A | null | true |
Bipointed.hasForget._proof_7 | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X.HomSubtype Y), ↑f X.toProd.2 = Y.toProd.2 | null | false |
SimpleGraph.Walk.Nil.rec | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} →
{G : SimpleGraph V} →
{v : V} →
{motive : {w : V} → (a : G.Walk v w) → a.Nil → Sort u_1} →
motive SimpleGraph.Walk.nil ⋯ → {w : V} → {a : G.Walk v w} → (t : a.Nil) → motive a t | null | false |
IsCyclotomicExtension.Rat.Three.eq_one_or_neg_one_of_unit_of_congruent | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) (u : (NumberField.RingOfIntegers K)ˣ)
[inst_1 : NumberField K] [IsCyclotomicExtension {3} ℚ K], (∃ n, (hζ.toInteger - 1) ^ 2 ∣ ↑u - ↑n) → u = 1 ∨ u = -1 | If a unit `u` is congruent to an integer modulo `λ ^ 2`, then `u = 1` or `u = -1`.
This is a special case of the so-called *Kummer's lemma*. | true |
Lean.Linter.LinterOptions.ctorIdx | Lean.Linter.Init | Lean.Linter.LinterOptions → ℕ | null | false |
SummationFilter.hasSum_symmetricIcc_iff | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : ℤ → α} {a : α},
HasSum f a (SummationFilter.symmetricIcc ℤ) ↔
Filter.Tendsto (fun N => ∑ n ∈ Finset.Icc (-↑N) ↑N, f n) Filter.atTop (nhds a) | null | true |
Lean.Server.FileWorker.InlayHintState.mk | Lean.Server.FileWorker.InlayHints | Array Lean.Elab.InlayHintInfo → ℕ → Option ℕ → Bool → Lean.Server.FileWorker.InlayHintState | null | true |
Polynomial.monic_zero_iff_subsingleton' | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic 0 ↔ (∀ (f g : Polynomial R), f = g) ∧ ∀ (a b : R), a = b | null | true |
Submodule.dualCoannihilator_bot | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⊥.dualCoannihilator = ⊤ | null | true |
Filter.add_bot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α] {f : Filter α}, f + ⊥ = ⊥ | null | true |
SSet.RelativeMorphism.Homotopy.postcomp_h | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y Z : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet} {f g : SSet.RelativeMorphism A B φ}
{C : Z.Subcomplex} {ψ : B.toSSet ⟶ C.toSSet} (h : f.Homotopy g) (f' : SSet.RelativeMorphism B C ψ)
{φψ : A.toSSet ⟶ C.toSSet} (fac : CategoryTheory.CategoryStruct.comp φ ψ = φψ),
(h.postcomp f' fac... | null | true |
IsLocallyConstant.of_constant | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (f : X → Y), (∀ (x y : X), f x = f y) → IsLocallyConstant f | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.alternatingGroup.commutator_perm_le._simp_1_7 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {S : Type u_3} [inst : CommMagma S] (a b : S), Commute a b = True | null | false |
Set.eq_restrict_iff | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {π : α → Type u_5} {s : Set α} {f : (a : ↑s) → π ↑a} {g : (a : α) → π a},
f = s.domRestrict g ↔ ∀ (a : α) (ha : a ∈ s), f ⟨a, ha⟩ = g a | **Alias** of `Set.eq_domRestrict_iff`. | true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.chevalley_mvPolynomial_mvPolynomial._simp_1_9 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {R : Type u_2} {S : Type u_3} {σ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Module R S]
{M : Submodule R S} {p : MvPolynomial σ S}, (p ∈ MvPolynomial.coeffsIn σ M) = ∀ (i : σ →₀ ℕ), p.coeff i ∈ M | null | false |
differentiableAt_iff_comp_const_sub | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {a b : 𝕜},
DifferentiableAt 𝕜 f a ↔ DifferentiableAt 𝕜 (fun x => f (b - x)) (b - a) | null | true |
AlgEquiv.aut | Mathlib.Algebra.Algebra.Equiv | {R : Type uR} →
{A₁ : Type uA₁} → [inst : CommSemiring R] → [inst_1 : Semiring A₁] → [inst_2 : Algebra R A₁] → Group (A₁ ≃ₐ[R] A₁) | [Stacks Tag 09HR](https://stacks.math.columbia.edu/tag/09HR) | true |
CategoryTheory.SmallCategoryOfSet.mk.sizeOf_spec | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type w} [inst : SizeOf Ω] (obj : Set Ω) (hom : ↑obj → ↑obj → Set Ω) (id : (X : ↑obj) → ↑(hom X X))
(comp : {X Y Z : ↑obj} → ↑(hom X Y) → ↑(hom Y Z) → ↑(hom X Z))
(id_comp :
autoParam (∀ {X Y : ↑obj} (f : ↑(hom X Y)), comp (id X) f = f) CategoryTheory.SmallCategoryOfSet.id_comp._autoParam)
(comp_id :
... | null | true |
_private.Mathlib.AlgebraicTopology.ExtraDegeneracy.0.CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.homotopy._proof_16 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {n : ℕ} (i : Fin (n + 1)) (k : Fin (n + 1 + 1)), i.succ.rev = k → ↑k + 1 = ↑i.castSucc.rev | null | false |
ShrinkingLemma.PartialRefinement.mk.noConfusion | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
{inst : TopologicalSpace X} →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
{P : Sort u} →
{toFun : ι → Set X} →
{carrier : Set ι} →
{isOpen : ∀ (i : ι), IsOpen (toFun i)} →
... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.