name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.RedRed.balance1._sparseCasesOn_1_6 | Batteries.Recycling.RBTree.WF | {α : Type u} →
{motive : RBTree.RBNode α → Sort u_1} →
(t : RBTree.RBNode α) →
((c : RBTree.RBColor) →
(l : RBTree.RBNode α) → (v : α) → (r : RBTree.RBNode α) → motive (RBTree.RBNode.node c l v r)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Int.Internal.Linear.Expr.toPoly'.go.eq_def | Init.Data.Int.Linear | ∀ (coeff : ℤ) (a : Int.Internal.Linear.Expr),
Int.Internal.Linear.Expr.toPoly'.go coeff a =
match (motive := Int.Internal.Linear.Expr → Int.Internal.Linear.Poly → Int.Internal.Linear.Poly) a with
| Int.Internal.Linear.Expr.num k => bif k == 0 then id else fun x => x.addConst (coeff.mul k)
| Int.Internal.L... | null | true |
Lean.Compiler.LCNF.Code.unreach.injEq | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (type type_1 : Lean.Expr),
(Lean.Compiler.LCNF.Code.unreach type = Lean.Compiler.LCNF.Code.unreach type_1) = (type = type_1) | null | true |
RelIso.sumLexCongr._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α₁ : Type u_3} {α₂ : Type u_4} {β₁ : Type u_1} {β₂ : Type u_2} {r₁ : α₁ → α₁ → Prop} {r₂ : α₂ → α₂ → Prop}
{s₁ : β₁ → β₁ → Prop} {s₂ : β₂ → β₂ → Prop} (e₁ : r₁ ≃r s₁) (e₂ : r₂ ≃r s₂) (a b : α₁ ⊕ α₂),
Sum.Lex s₁ s₂ ((e₁.sumCongr e₂.toEquiv) a) ((e₁.sumCongr e₂.toEquiv) b) ↔ Sum.Lex r₁ r₂ a b | null | false |
MulAction.mem_fixedPoints' | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] {a : α},
a ∈ MulAction.fixedPoints M α ↔ ∀ a' ∈ MulAction.orbit M a, a' = a | null | true |
Algebra.Extension.cotangentEquiv._proof_4 | Mathlib.RingTheory.Extension.Basic | ∀ {S : Type u_1} [inst : CommRing S], RingHomInvPair (RingHom.id S) (RingHom.id S) | null | false |
SimpleGraph.Subgraph.IsInduced | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → G.Subgraph → Prop | A subgraph is called an *induced subgraph* if vertices of `G'` are adjacent if
they are adjacent in `G`. | true |
Std.DTreeMap.Internal.Zipper.toList | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Zipper α β → List ((a : α) × β a) | null | true |
MeromorphicOn.divisor_fun_mul | Mathlib.Analysis.Meromorphic.Divisor | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {U : Set 𝕜} {f₁ f₂ : 𝕜 → 𝕜},
MeromorphicOn f₁ U →
MeromorphicOn f₂ U →
(∀ z ∈ U, meromorphicOrderAt f₁ z ≠ ⊤) →
(∀ z ∈ U, meromorphicOrderAt f₂ z ≠ ⊤) →
MeromorphicOn.divisor (fun z => f₁ z * f₂ z) U = MeromorphicOn.divisor f₁ U + Me... | If orders are finite, the divisor of the product of two meromorphic functions is the sum of the
divisors.
| true |
Rat.num_natCast | Init.Data.Rat.Lemmas | ∀ (n : ℕ), (↑n).num = ↑n | null | true |
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.isDershowitzMannaLT_of_transGen_oneStep | Mathlib.Data.Multiset.DershowitzManna | ∀ {α : Type u_1} [inst : Preorder α] {M N : Multiset α},
Relation.TransGen Multiset.OneStep✝ M N → M.IsDershowitzMannaLT N | null | true |
MeasureTheory.SimpleFunc.piecewise_univ | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f g : MeasureTheory.SimpleFunc α β),
MeasureTheory.SimpleFunc.piecewise Set.univ ⋯ f g = f | null | true |
Std.DHashMap.Raw.get!_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k k' : α} [hi : Inhabited (β k')] {f : Option (β k) → Option (β k)},
m.WF → (m.alter k f).get! k' = if heq : (k == k') = true then (Option.map (cast ⋯) (f (m.get? k))).get! else m.get! k' | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_5 | Std.Data.DTreeMap.Internal.Operations | ¬0 ≤ 0 + 1 → False | null | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.Element.cases.elim | Lean.Compiler.LCNF.ToLCNF | {motive : Lean.Compiler.LCNF.ToLCNF.Element✝ → Sort u} →
(t : Lean.Compiler.LCNF.ToLCNF.Element✝) →
Lean.Compiler.LCNF.ToLCNF.Element.ctorIdx✝ t = 3 →
((p : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
(cases : Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure) →
mo... | null | false |
AffineIsometryEquiv.coe_mk' | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V₁ : Type u_3} {V₂ : Type u_4} {P₁ : Type u_6} {P₂ : Type u_8} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V₁] [inst_2 : NormedSpace 𝕜 V₁] [inst_3 : PseudoMetricSpace P₁]
[inst_4 : NormedAddTorsor V₁ P₁] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : P... | null | true |
CategoryTheory.Limits.WalkingReflexivePair.rec | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {motive : CategoryTheory.Limits.WalkingReflexivePair → Sort u} →
motive CategoryTheory.Limits.WalkingReflexivePair.zero →
motive CategoryTheory.Limits.WalkingReflexivePair.one → (t : CategoryTheory.Limits.WalkingReflexivePair) → motive t | null | false |
Std.Time.WallTime.noConfusion | Std.Time.DateTime.WallTime | {P : Sort u} → {t t' : Std.Time.WallTime} → t = t' → Std.Time.WallTime.noConfusionType P t t' | null | false |
Std.HashSet.Raw.noConfusion | Std.Data.HashSet.Raw | {P : Sort u_1} →
{α : Type u} →
{t : Std.HashSet.Raw α} →
{α' : Type u} → {t' : Std.HashSet.Raw α'} → α = α' → t ≍ t' → Std.HashSet.Raw.noConfusionType P t t' | null | false |
HomotopicalAlgebra.Precylinder.op._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A : C} (P : HomotopicalAlgebra.Precylinder A),
(CategoryTheory.CategoryStruct.comp P.π.op P.i₀.op).unop = (CategoryTheory.CategoryStruct.id (Opposite.op A)).unop | null | false |
Concept.isUpperSet_intent_le._simp_1 | Mathlib.Order.Concept | ∀ {α : Type u_5} [inst : Preorder α] (c : Concept α α fun x1 x2 => x1 ≤ x2), IsUpperSet c.intent = True | null | false |
Nat.sq_mul_squarefree_of_pos' | Mathlib.Data.Nat.Squarefree | ∀ {n : ℕ}, 0 < n → ∃ a b, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1) | null | true |
Bialgebra.TensorProduct.assoc._proof_4 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_4) (C : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S]
[inst_6 : IsScalarTower R S A] [inst_7 : Semiring C] [inst_8 : Bialgebra S C], SMulCommClass R S (TensorProduct... | null | false |
BoxIntegral.TaggedPrepartition.distortion_le_of_mem | Mathlib.Analysis.BoxIntegral.Partition.Tagged | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.TaggedPrepartition I) [inst : Fintype ι],
J ∈ π → J.distortion ≤ π.distortion | null | true |
instZeroLieSubalgebra | Mathlib.Algebra.Lie.Subalgebra | (R : Type u) →
(L : Type v) → [inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → Zero (LieSubalgebra R L) | The zero algebra is a subalgebra of any Lie algebra. | true |
CategoryTheory.Limits.WalkingReflexivePair.Hom.rightCompReflexion.elim | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {motive : (a a_1 : CategoryTheory.Limits.WalkingReflexivePair) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Limits.WalkingReflexivePair} →
(t : a.Hom a_1) →
t.ctorIdx = 4 →
motive CategoryTheory.Limits.WalkingReflexivePair.one CategoryTheory.Limits.WalkingReflexivePair.one
CategoryThe... | null | false |
CategoryTheory.Functor.LeftExtension.postcompose₂_obj_hom_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} {D' : Type u_6} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
[inst_3 : CategoryTheory.Category.{v_6, u_6} D'] (L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C... | null | true |
Mathlib.Tactic.ClickSuggestions.ApplyLemma.rec | Mathlib.Tactic.ClickSuggestions.Apply | {motive : Mathlib.Tactic.ClickSuggestions.ApplyLemma → Sort u} →
((name : Mathlib.Tactic.ClickSuggestions.Premise) → motive { name := name }) →
(t : Mathlib.Tactic.ClickSuggestions.ApplyLemma) → motive t | null | false |
Mathlib.Tactic.Bicategory.structuralIsoOfExpr_whiskerRight | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g : a ⟶ b} (h : b ⟶ c) (η : f ⟶ g) (η' : f ≅ g),
η'.hom = η → (CategoryTheory.Bicategory.whiskerRightIso η' h).hom = CategoryTheory.Bicategory.whiskerRight η h | null | true |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.ProperAction.0.UpperHalfPlane.σ_eventuallyEq._simp_1_3 | Mathlib.Analysis.Complex.UpperHalfPlane.ProperAction | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [Nontrivial M₀] (u : M₀ˣ), (↑u = 0) = False | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.match_56 | Std.Sat.AIG.CNF | (aig : Std.Sat.AIG ℕ) →
(upper : ℕ) →
(h : upper < aig.decls.size) →
(state : Std.Sat.AIG.toCNF.State✝ aig) →
(lhs rhs : Std.Sat.AIG.Fanin) →
(this : lhs.gate < upper ∧ rhs.gate < upper) →
(motive : { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state out lhs.gate ⋯ } → Sort u... | null | false |
LinearEquiv.image_closure_of_convex | Mathlib.Analysis.LocallyConvex.WeakSpace | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : AddCommGroup F] [inst_4 : Module 𝕜 F] [inst_5 : Module ℝ E] [IsScalarTower ℝ 𝕜 E] [inst_7 : Module ℝ F]
[IsScalarTower ℝ 𝕜 F] [inst_9 : TopologicalSpace E] [IsTopologicalAddGroup E] [Cont... | If `e` is a linear isomorphism between two locally convex spaces, and `e` induces (via
precomposition) an isomorphism between their continuous duals, then `e` commutes with the closure
on convex sets.
The hypotheses hold automatically for `e := toWeakSpace 𝕜 E`, see `Convex.toWeakSpace_closure`. | true |
Affine.Simplex.sign_signedInfDist_lineMap_incenter_touchpoint | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) {i j : Fin (n + 1)},
i ≠ j →
∀ {r : ℝ},
r ∈ Set.Icc 0 1 →
SignType.sign ((s.signedInfDist j)... | null | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.addLValArg._proof_11 | Lean.Elab.App | ∀ (args : Array Lean.Elab.Term.Arg) (explicit : Bool)
(__s :
Option (Array Lean.Elab.Term.Arg × Array Lean.Elab.Term.NamedArg) ×
ℕ × Array Lean.Elab.Term.NamedArg × Array Lean.Name × Subarray Lean.BinderInfo)
(bInfo : Lean.BinderInfo), __s.2.1 ≤ args.size ∧ (explicit || bInfo.isExplicit) = true → ¬__s.2.1... | null | false |
CategoryTheory.Limits.Bicones.functoriality_obj_pt | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {D : Type uD} [inst_2 : CategoryTheory.Category.{uD', uD} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : J → C) (G : CategoryTheory.Functor C D)
[inst_4 : G.PreservesZeroMorph... | null | true |
_private.Lean.MetavarContext.0.Lean.MetavarContext.MkBinding.visit._unsafe_rec | Lean.MetavarContext | Array Lean.Expr → Lean.Expr → Lean.MetavarContext.MkBinding.M Lean.Expr | null | false |
Aesop.BestFirstQueue.ActiveGoal.mk | Aesop.Search.Queue | Aesop.GoalRef → Aesop.Percent → Aesop.Iteration → Aesop.Iteration → Aesop.BestFirstQueue.ActiveGoal | null | true |
SMulMemClass.toModule' | Mathlib.Algebra.Module.Submodule.Defs | (S : Type u_2) →
(R' : Type u_3) →
(R : Type u_4) →
(A : Type u_5) →
[inst : Semiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Semiring R'] →
[inst_4 : SMul R' R] →
[inst_5 : Module R' A] →
... | This can't be an instance because Lean wouldn't know how to find `R`, but we can still use
this to manually derive `Module` on specific types. | true |
deriv.lhopital_zero_right_on_Ico | Mathlib.Analysis.Calculus.LHopital | ∀ {a b : ℝ} {l : Filter ℝ} {f g : ℝ → ℝ},
a < b →
DifferentiableOn ℝ f (Set.Ioo a b) →
ContinuousOn f (Set.Ico a b) →
ContinuousOn g (Set.Ico a b) →
(∀ x ∈ Set.Ioo a b, deriv g x ≠ 0) →
f a = 0 →
g a = 0 →
Filter.Tendsto (fun x => deriv f x / deriv... | null | true |
_private.Mathlib.GroupTheory.Index.0.Subgroup.index_eq_two_iff'._simp_1_2 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : DivisionMonoid G] (a b : G), b⁻¹ * a⁻¹ = (a * b)⁻¹ | null | false |
PowerSeries.isUnit_iff_constantCoeff | Mathlib.RingTheory.PowerSeries.Inverse | ∀ {R : Type u_1} [inst : Ring R] {φ : PowerSeries R}, IsUnit φ ↔ IsUnit (PowerSeries.constantCoeff φ) | null | true |
HomotopyCategory.instIsTriangulatedClosed₃IntUpPlus | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Limits.HasBinaryBiproducts C],
(HomotopyCategory.plus C).IsTriangulatedClosed₃ | null | true |
Equiv.Perm.IsCycle.nonempty_support | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq α] {g : Equiv.Perm α}, g.IsCycle → g.support.Nonempty | Support of a cycle is nonempty | true |
List.IsInfix.reverse | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+: l₂ → l₁.reverse <:+: l₂.reverse | null | true |
_private.Mathlib.RingTheory.DedekindDomain.AdicValuation.0.IsDedekindDomain.HeightOneSpectrum.valuation_div_le_one_iff._simp_1_3 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R),
(v.intValuation r < 1) = (r ∈ v.asIdeal) | null | false |
instAddCommGroupFreeAbelianGroup._proof_11 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1),
autoParam (∀ (n : ℕ) (x : FreeAbelianGroup α), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
UInt16.toUInt8_lt._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a.toUInt8 < b.toUInt8) = (a % 256 < b % 256) | null | false |
Lean.Parser.Error._sizeOf_1 | Lean.Parser.Types | Lean.Parser.Error → ℕ | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Comp.0.ContDiffWithinAt.comp.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_4} {F : Type u_2} {G : Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {t : Set F} {g : F → G} {... | null | false |
AbstractMeasure.prodMk_eq_prodMk' | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ {X : Type u_1} {Y : Type u_2} {R : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : CommRing R] [inst_3 : TopologicalSpace R] [inst_4 : IsTopologicalRing R] (μ : AbstractMeasure X R R)
(ν : AbstractMeasure Y R R) [inst_5 : CompactSpace X] [inst_6 : CompactSpace Y] [inst_7 : T2Space X]... | For profinite spaces, the two product structures on measures agree. | true |
LinearIndepOn.id_union | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {s t : Set M},
LinearIndepOn R id s →
LinearIndepOn R id t → Disjoint (Submodule.span R s) (Submodule.span R t) → LinearIndepOn R id (s ∪ t) | null | true |
Lean.LocalDecl.rec | Lean.LocalContext | {motive : Lean.LocalDecl → Sort u} →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) → motive (Lean.LocalDecl.cdecl index fvarId userName type bi kind)) →
((index : ℕ) →
... | null | false |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence._proof_14 | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C]
(F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat))
(ι : Type u_1) [inst_1 : Unique ι] {X S : C} (f : X ⟶ S) {D₁ D₂ : F.DescentDataAsCoalgebra fun x => f} (α : D₁ ⟶ D₂),
... | null | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeUsingDefaultPrio.synthesizeUsingDefault._unsafe_rec | Lean.Elab.SyntheticMVars | Lean.MVarId → Lean.Elab.TermElabM Bool | null | false |
Polynomial.piEquiv | Mathlib.Algebra.Polynomial.Eval.Coeff | {ι : Type u_2} →
[Finite ι] →
(R : ι → Type u_1) → [inst : (i : ι) → Semiring (R i)] → Polynomial ((i : ι) → R i) ≃+* ((i : ι) → Polynomial (R i)) | The polynomial ring over a finite product of rings is isomorphic to
the product of polynomial rings over individual rings. | true |
SaturatedAddSubmonoid.instCompleteLattice._proof_5 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M] (a b : SaturatedAddSubmonoid M), Lattice.inf a b ≤ b | null | false |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_20 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt8), a * 0 = 0 | null | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.mem_inf_principal'._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α}, Disjoint (a ⊓ b) c = Disjoint a (b ⊓ c) | null | false |
Continuous.strictAnti_of_inj_boundedOrder | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
[inst_7 : BoundedOrder α] {f : α → δ}, Continuous f → f ⊤ ≤ f ⊥ → Function.Injective f → StrictA... | null | true |
MeasureTheory.Measure.IsCondKernel.disintegrate | Mathlib.Probability.Kernel.Disintegration.Basic | ∀ {α : Type u_1} {Ω : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω} {ρ : MeasureTheory.Measure (α × Ω)}
{ρCond : ProbabilityTheory.Kernel α Ω} [self : ρ.IsCondKernel ρCond], ρ.fst.compProd ρCond = ρ | null | true |
CategoryTheory.Functor.OfSequence.map.match_3 | Mathlib.CategoryTheory.Functor.OfSequence | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
(motive : (x : ℕ → C) → ((n : ℕ) → x n ⟶ x (n + 1)) → ℕ → ℕ → Sort u_3) →
(x : ℕ → C) →
(x_1 : (n : ℕ) → x n ⟶ x (n + 1)) →
(x_2 x_3 : ℕ) →
((x : ℕ → C) → (x_4 : (n : ℕ) → x n ⟶ x (n + 1)) → motive x x_4 0 0) →
... | null | false |
MeasureTheory.Measure.AbsolutelyContinuous.comp | Mathlib.Probability.Kernel.Composition.MeasureComp | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ ν : MeasureTheory.Measure α}
{κ η : ProbabilityTheory.Kernel α β},
μ.AbsolutelyContinuous ν →
(∀ᵐ (a : α) ∂μ, (κ a).AbsolutelyContinuous (η a)) → (μ.bind ⇑κ).AbsolutelyContinuous (ν.bind ⇑η) | null | true |
Std.OrientedCmp.rec | Init.Data.Order.Ord | {α : Type u} →
{cmp : α → α → Ordering} →
{motive : Std.OrientedCmp cmp → Sort u_1} →
((eq_swap : ∀ {a b : α}, cmp a b = (cmp b a).swap) → motive ⋯) → (t : Std.OrientedCmp cmp) → motive t | null | false |
linearDepOn_iff' | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {s : Set ι} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] {v : ι → M},
¬LinearIndepOn R v s ↔ ∃ f ∈ Finsupp.supported R R s, (Finsupp.linearCombination R v) f = 0 ∧ f ≠ 0 | An indexed set of vectors is linearly dependent iff there is a nontrivial
`Finsupp.linearCombination` of the vectors that is zero. | true |
Array.foldl_flatten' | Init.Data.Array.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {f : β → α → β} {b : β} {xss : Array (Array α)} {stop : ℕ},
stop = xss.flatten.size → Array.foldl f b xss.flatten 0 stop = Array.foldl (fun b xs => Array.foldl f b xs) b xss | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterLong | Std.Time.Format.Basic | Std.Time.DateFormatSymbols → Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter | null | true |
MeasurableNeg.rec | Mathlib.MeasureTheory.Group.Arithmetic | {G : Type u_2} →
[inst : Neg G] →
[inst_1 : MeasurableSpace G] →
{motive : MeasurableNeg G → Sort u} →
((measurable_neg : Measurable Neg.neg) → motive ⋯) → (t : MeasurableNeg G) → motive t | null | false |
Con.comap._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] (f : M → N),
(∀ (x y : M), f (x * y) = f x * f y) →
∀ (c : Con N) (w x y z : M),
(Setoid.comap f c.toSetoid) w x → (Setoid.comap f c.toSetoid) y z → c (f (w * y)) (f (x * z)) | null | false |
CochainComplex.opcycles₀Iso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | (ComplexShape.up ℕ).prev 0 = 0 | null | false |
Subfield.mem_comap._simp_1 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] {s : Subfield L} {f : K →+* L} {x : K},
(x ∈ Subfield.comap f s) = (f x ∈ s) | null | false |
Std.DTreeMap.minKeyD_insertIfNew_le_minKeyD | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.isEmpty = false →
∀ {k : α} {v : β k} {fallback : α}, (cmp ((t.insertIfNew k v).minKeyD fallback) (t.minKeyD fallback)).isLE = true | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_5.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(motive :
(l_1 : Std.DTreeMap.Internal.Impl α β) →
l_1.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond l_1.size (Std.DTreeMap.Internal.Impl.inner rs k v l r).size →
Sort u_3)
(ls :... | null | true |
Std.DTreeMap.Internal.RooSliceData._sizeOf_1 | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} → {inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → Std.DTreeMap.Internal.RooSliceData α β → ℕ | null | false |
AddGrpCat.instCategory.eq_1 | Mathlib.Algebra.Category.Grp.Basic | AddGrpCat.instCategory =
{ Hom := fun X Y => X.Hom Y, id := fun X => { hom' := AddMonoidHom.id ↑X },
comp := fun {X Y Z} f g => { hom' := g.hom'.comp f.hom' }, id_comp := @AddGrpCat.instCategory._proof_1,
comp_id := @AddGrpCat.instCategory._proof_2, assoc := @AddGrpCat.instCategory._proof_3 } | null | true |
isOfFinAddOrder_iff_zsmul_eq_zero | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : SubtractionMonoid G] {x : G}, IsOfFinAddOrder x ↔ ∃ n, n ≠ 0 ∧ n • x = 0 | null | true |
TopHom.symm_dual_comp | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : LE α] [inst_1 : OrderTop α] [inst_2 : LE β] [inst_3 : OrderTop β]
[inst_4 : LE γ] [inst_5 : OrderTop γ] (g : BotHom βᵒᵈ γᵒᵈ) (f : BotHom αᵒᵈ βᵒᵈ),
TopHom.dual.symm (g.comp f) = (TopHom.dual.symm g).comp (TopHom.dual.symm f) | null | true |
CompleteSublattice.sInfClosed' | Mathlib.Order.CompleteSublattice | ∀ {α : Type u_1} [inst : CompleteLattice α] (self : CompleteSublattice α) ⦃s : Set α⦄,
s ⊆ self.carrier → sInf s ∈ self.carrier | null | true |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._aux_13 | Mathlib.CategoryTheory.Bicategory.Monad.Basic | {B : Type u_3} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h ≅
CategoryTheory.Categ... | null | false |
CategoryTheory.isCofilteredOrEmpty_of_directed_ge | Mathlib.CategoryTheory.Filtered.Basic | ∀ (α : Type u) [inst : Preorder α] [IsCodirectedOrder α], CategoryTheory.IsCofilteredOrEmpty α | null | true |
_private.Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric.0.Complex.multiset_prod_div_multiset_prod_mul._simp_1_1 | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.Topology.Order.Bornology.0.Pi.instIsOrderBornology._simp_5 | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} {s : Set α} [inst : Bornology α] [inst_1 : Preorder α] [IsOrderBornology α],
Bornology.IsBounded s = (BddBelow s ∧ BddAbove s) | null | false |
NumberField.mixedEmbedding.fundamentalCone.isCompact_compactSet | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
IsCompact (NumberField.mixedEmbedding.fundamentalCone.compactSet K) | null | true |
AddSemiconjBy.isTrans | Mathlib.Algebra.Group.Semiconj.Defs | ∀ {S : Type u_1} [inst : AddSemigroup S], IsTrans S fun a b => ∃ c, AddSemiconjBy c a b | The relation “there exists an element that semiconjugates `a` to `b`” on an
additive semigroup is transitive. | true |
Lean.Grind.CommRing.Poly.powC_nc.eq_def | Init.Grind.Ring.CommSolver | ∀ (p : Lean.Grind.CommRing.Poly) (k c : ℕ),
p.powC_nc k c =
match k with
| 0 => Lean.Grind.CommRing.Poly.num 1
| 1 => p
| k.succ => (p.powC_nc k c).mulC_nc p c | null | true |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functorToMonoOver._proof_5 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
[CategoryTheory.IsGrothendieckAbelian.{u_1, u_2, u_3} C] (J : Type u_1),
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete J) C | null | false |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Embeddings.0.IsCyclotomicExtension.Rat.nrComplexPlaces_eq_totient_div_two._simp_1_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Embeddings | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | null | false |
AddActionHom.End.equivAddOpposite_symm_apply_apply | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} [inst : AddMonoid M] (m : Mᵃᵒᵖ) (x : M),
(AddActionHom.End.equivAddOpposite.symm m) x = x + AddOpposite.unop m | null | true |
LinearEquiv.transvection.eq_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {f : Module.Dual R V}
{v : V} (h : f v = 0),
LinearEquiv.transvection h =
{ toFun := ⇑(LinearMap.transvection f v), map_add' := ⋯, map_smul' := ⋯, invFun := ⇑(LinearMap.transvection f (-v)),
left_inv := ⋯, righ... | null | true |
Lean.Meta.NativeEqTrueResult._sizeOf_1 | Lean.Meta.Native | Lean.Meta.NativeEqTrueResult → ℕ | null | false |
Algebra.inf_toSubsemiring | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S T : Subalgebra R A),
(S ⊓ T).toSubsemiring = S.toSubsemiring ⊓ T.toSubsemiring | null | true |
ISize.toNatClampNeg_ofBitVec | Init.Data.SInt.Lemmas | ∀ (b : BitVec System.Platform.numBits), (ISize.ofBitVec b).toNatClampNeg = b.toInt.toNat | null | true |
AddSubgroup.index_eq_one | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.index = 1 ↔ H = ⊤ | null | true |
Directed.finset_le | Mathlib.Data.Finset.Order | ∀ {α : Type u} {r : α → α → Prop} [IsTrans α r] {ι : Type u_1} [hι : Nonempty ι] {f : ι → α},
Directed r f → ∀ (s : Finset ι), ∃ z, ∀ i ∈ s, r (f i) (f z) | null | true |
_private.Mathlib.Algebra.Lie.LieTheorem.0.LieModule.weightSpaceOfIsLieTower_aux._simp_1_11 | Mathlib.Algebra.Lie.LieTheorem | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | null | false |
LinearMap.eqOn_eqLocus | Mathlib.Algebra.Module.Submodule.EqLocus | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_3} {M₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f g : M →ₛₗ[τ₁₂] M₂}, Set.EqOn ⇑f ⇑g ↑(f.eqLocus g) | null | true |
CategoryTheory.MorphismProperty.IsCardinalForSmallObjectArgument | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.MorphismProperty C → (κ : Cardinal.{w}) → [Fact κ.IsRegular] → [OrderBot κ.ord.ToType] → Prop | Given `I : MorphismProperty C` and a regular cardinal `κ : Cardinal.{w}`,
this property asserts the technical conditions which allow to proceed
to the small object argument by doing a construction by transfinite
induction indexed by the well-ordered type `κ.ord.ToType`. | true |
ProbabilityTheory.Kernel.IsFiniteKernel.comap | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {g : γ → α} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsFiniteKernel κ]
(hg : Measurable g), ProbabilityTheory.IsFiniteKernel (κ.comap g hg) | null | true |
WithTop.untop₀_max | Mathlib.Algebra.Order.WithTop.Untop0 | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] {a b : WithTop α},
a ≠ ⊤ → b ≠ ⊤ → (max a b).untop₀ = max a.untop₀ b.untop₀ | null | true |
LinearMap.IsAdjointPair | Mathlib.LinearAlgebra.SesquilinearForm.Basic | {R : Type u_1} →
{M : Type u_5} →
{M₁ : Type u_6} →
{M₃ : Type u_8} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : AddCommMonoid M₁] →
[inst_4 : Module R M₁] →
[inst_5 : AddCommMonoid M₃... | Given a pair of modules equipped with bilinear maps, this is the condition for a pair of
maps between them to be mutually adjoint. | true |
_private.Mathlib.Algebra.Order.Nonneg.Ring.0.Nonneg.noZeroDivisors._simp_2 | Mathlib.Algebra.Order.Nonneg.Ring | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.