name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.Kernel.HasSubgaussianMGF.measure_pos_eq_zero_of_hasSubGaussianMGF_zero._simp_1_2 | Mathlib.Probability.Moments.SubGaussian | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Std.Roc.Sliceable.rec | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Roc.Sliceable α β γ → Sort u_1} →
((mkSlice : α → Std.Roc β → γ) → motive { mkSlice := mkSlice }) → (t : Std.Roc.Sliceable α β γ) → motive t | null | false |
Std.Slice.Internal.ListSliceData.mk.noConfusion | Init.Data.Slice.List.Basic | {α : Type u} →
{P : Sort u_1} →
{list : List α} →
{stop : Option ℕ} →
{list' : List α} →
{stop' : Option ℕ} →
{ list := list, stop := stop } = { list := list', stop := stop' } → (list ≍ list' → stop = stop' → P) → P | null | false |
Real.volume_pi_Ico_toReal | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] {a b : ι → ℝ},
a ≤ b → (MeasureTheory.volume (Set.univ.pi fun i => Set.Ico (a i) (b i))).toReal = ∏ i, (b i - a i) | null | true |
Finpartition.restrict._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {a b : α}
(P : Finpartition a), ((Finset.image (fun x => x ⊓ b) P.parts).erase ⊥).SupIndep id | null | false |
HomotopicalAlgebra.AttachCells.ofArrowIso._proof_1 | Mathlib.AlgebraicTopology.RelativeCellComplex.AttachCells | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {α : Type u_4} {A B : α → C} {g : (a : α) → A a ⟶ B a}
{X₁ X₂ : C} {f : X₁ ⟶ X₂} (c : HomotopicalAlgebra.AttachCells g f) {Y₁ Y₂ : C} {f' : Y₁ ⟶ Y₂}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f'),
CategoryTheory.IsPushout (CategoryTheory... | null | false |
abs_setIntegral_mulExpNegMulSq_comp_sub_le_mul_measure | Mathlib.Analysis.SpecialFunctions.MulExpNegMulSqIntegral | ∀ {E : Type u_1} [inst : TopologicalSpace E] [inst_1 : MeasurableSpace E] [BorelSpace E] {P : MeasureTheory.Measure E}
[MeasureTheory.IsFiniteMeasure P] {ε : ℝ} {K : Set E},
IsCompact K →
MeasurableSet K →
∀ (f g : C(E, ℝ)) {δ : ℝ},
0 < ε →
(∀ x ∈ K, |g x - f x| < δ) →
|∫ (x ... | null | true |
WithTop.add_right_inj | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithTop α} [IsRightCancelAdd α], z ≠ ⊤ → (x + z = y + z ↔ x = y) | null | true |
CategoryTheory.Comonad.comparison._proof_3 | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R) (X : C),
CategoryTheory.CategoryStruct.comp (L.map (h.unit.app X)) (h.toComonad.δ.app (L.obj X)) =
Categor... | null | false |
Units.instCommGroupUnits.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u_1} [inst : CommMonoid α], Units.instCommGroupUnits = { toGroup := Units.instGroup, mul_comm := ⋯ } | null | true |
Ordnode.map._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → {β : Type u_2} → (α → β) → Ordnode α → Ordnode β | null | false |
SimpleGraph.Subgraph.Adj.ne | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H : G.Subgraph} {u v : V}, H.Adj u v → u ≠ v | null | true |
RatFunc.intDegree_add_le | Mathlib.FieldTheory.RatFunc.Degree | ∀ {K : Type u} [inst : Field K] {x y : RatFunc K}, y ≠ 0 → x + y ≠ 0 → (x + y).intDegree ≤ max x.intDegree y.intDegree | null | true |
Std.DHashMap.getKeyD_insertIfNew | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k a fallback : α} {v : β k},
(m.insertIfNew k v).getKeyD a fallback = if (k == a) = true ∧ k ∉ m then k else m.getKeyD a fallback | null | true |
Lean.Server.DirectImports.ordered | Lean.Server.References | Lean.Server.DirectImports → Array Lean.Server.ModuleImport | Imports as they occurred in the module. | true |
CategoryTheory.SmallObject.transfiniteCompositionOfShapeιIterationAppRight._proof_3 | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ (κ : Cardinal.{u_1}) (j : κ.ord.ToType), j ≤ Order.succ j | null | false |
HomologicalComplex.instModuleHom._proof_8 | Mathlib.Algebra.Homology.Linear | ∀ {R : Type u_4} [inst : Semiring R] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {ι : Type u_1} {c : ComplexShape ι}
(X Y : HomologicalComplex C c) (x x_1 : R) (x_2 : X ⟶ Y), (x + x_1) • x_2 = x • x_2 + x_1 • x_2 | null | false |
SimpleGraph.TripartiteFromTriangles.toTriangle.match_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (a' : α) (b' : β) (c' : γ), motive (a', b', c')) → motive x | null | false |
Mathlib.Tactic.TFAE.proveChain._unsafe_rec | Mathlib.Tactic.TFAE | Array (ℕ × ℕ × Lean.Expr) →
Array Q(Prop) →
ℕ → List ℕ → (P : Q(Prop)) → (l : Q(List Prop)) → Lean.MetaM Q(List.IsChain (fun x1 x2 => x1 → x2) («$P» :: «$l»)) | null | false |
CategoryTheory.Functor.currying_inverse_obj_obj_obj | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C) (Y : D),
((CategoryTheory.Functor.currying.inverse.obj F).obj X).obj Y = F.obj (X, Y) | null | true |
LiouvilleWith.mul_rat_iff | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | ∀ {p x : ℝ} {r : ℚ}, r ≠ 0 → (LiouvilleWith p (x * ↑r) ↔ LiouvilleWith p x) | The product `x * r`, `r : ℚ`, `r ≠ 0`, is a Liouville number with exponent `p` if and only if
`x` satisfies the same condition. | true |
Nondet.filterM | Batteries.Control.Nondet.Basic | {σ : Type} →
{m : Type → Type} →
[Monad m] → [inst : Lean.MonadBacktrack σ m] → {α : Type} → (α → m (ULift.{0, 0} Bool)) → Nondet m α → Nondet m α | Filter a nondeterministic value using a monadic predicate. | true |
CategoryTheory.Hom.addEquivCongrRight.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N : C} [inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.AddMonObj N] (e : M ≅ N)
[inst_4 : CategoryTheory.IsAddMonHom e.hom] (X : C),
CategoryTheory.Hom.addEquivCongrRight e X =
... | null | true |
NonUnitalAlgHom.snd_prod | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} [inst : Monoid R] {A : Type v} {B : Type w} {C : Type w₁} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : NonUnitalNonAssocSemiring C]
[inst_5 : DistribMulAction R B] [inst_6 : DistribMulAction R C] (f : A →ₙₐ[R] B) (g : A →ₙₐ[R]... | null | true |
Module.IsTorsionFree.of_faithfulSMul | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[FaithfulSMul R A] [inst_4 : Semiring S] [inst_5 : Module S R] [inst_6 : Module S A] [IsScalarTower S R A]
[Module.IsTorsionFree S A], Module.IsTorsionFree S R | null | true |
AddOpposite.opUniformEquivRight._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous AddOpposite.opEquiv.toFun | null | false |
CategoryTheory.Triangulated.TStructure.triangleLEGEIsoTriangleLTGE._proof_2 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | false |
Int.tdiv_left_inj | Init.Data.Int.DivMod.Lemmas | ∀ {a b d : ℤ}, d ∣ a → d ∣ b → (a.tdiv d = b.tdiv d ↔ a = b) | null | true |
Module.eqIdeal._proof_3 | Mathlib.RingTheory.Ideal.Defs | ∀ (R : Type u_1) {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m m' : M),
0 ∈ {r | r • m = r • m'} | null | false |
measurableSet_generateFrom_of_mem_supClosure | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {s : Set (Set α)} {t : Set α}, t ∈ supClosure s → MeasurableSet t | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastExtractAndExtendBit._simp_1_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop | ∀ {n : ℕ}, (n < 1) = (n = 0) | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace.0.volumePreservingSymmMeasurableEquivToLpProdAux._proof_4 | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | RingHomCompTriple (RingHom.id ℝ) (RingHom.id ℝ) (RingHom.id ℝ) | null | false |
NonUnitalIsometricContinuousFunctionalCalculus.norm_quasispectrum_le._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.splitTarget?.go._unsafe_rec | Lean.Meta.Tactic.Split | Lean.MVarId → Bool → Bool → Lean.Expr → Lean.ExprSet → Lean.MetaM (Option (List Lean.MVarId)) | null | false |
List.getElem!_inj | Init.Data.List.Pairwise | ∀ {α : Type u_1} {i j : ℕ} [inst : Inhabited α] {xs : List α},
i < xs.length → j < xs.length → xs.Nodup → (xs[i]! = xs[j]! ↔ i = j) | null | true |
Tactic.ComputeAsymptotics.Monomial.nil_toFun | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ {coef : ℝ} {basis : Tactic.ComputeAsymptotics.Basis}, { coef := coef, unit := [] }.toFun basis = fun x => coef | null | true |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieIdeal.coe_lcs_eq._simp_1_2 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊤) = True | null | false |
Std.TreeSet.Raw.isEmpty_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.insert k).isEmpty = false | null | true |
WeierstrassCurve.Jacobian.Point.mk_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [inst_1 : Nontrivial R] {X Y : R}
(h : W'.NonsingularLift ⟦![X, Y, 1]⟧), { point := ⟦![X, Y, 1]⟧, nonsingular := h } ≠ 0 | null | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_finset_disjoint_balls_large_measure._simp_1_20 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
Std.DTreeMap.Internal.Unit.RooSliceData | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) → [Ord α] → Type u | null | true |
MvPowerSeries.coeff_mul_left_one_sub_of_lt_order | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} (d : σ →₀ ℕ),
↑(Finsupp.degree d) < g.order → (MvPowerSeries.coeff d) (f * (1 - g)) = (MvPowerSeries.coeff d) f | null | true |
MeasureTheory.projectiveFamilyContent_eq | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {s : Set ((i : ι) → α i)}
(hP : MeasureTheory.IsProjectiveMeasureFamily P),
(MeasureTheory.projectiveFamilyContent hP) s = MeasureTheory.projectiveFamilyFun P s | null | true |
norm_add₄_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a b c d : E}, ‖a + b + c + d‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ + ‖d‖ | **Triangle inequality** for the norm. | true |
Lean.Parser.Term.completion.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.AlgebraicGeometry.Scheme.0.AlgebraicGeometry.basicOpen_eq_of_affine._simp_1_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.findPrefixTranslation?.go._f | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.TranslateData →
Lean.Environment →
(n : Lean.Name) →
Lean.Name.below (motive := fun n => List String → Option Mathlib.Tactic.Translate.TranslationInfo) n →
List String → Option Mathlib.Tactic.Translate.TranslationInfo | null | false |
CategoryTheory.Functor.whiskerRight_id | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor C D}
(F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (CategoryTheory.NatTrans.id G) ... | null | true |
AffineSubspace.mem_direction_iff_eq_vsub_left | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P}, p ∈ s → ∀ (v : V), v ∈ s.direction ↔ ∃ p₂ ∈ s, v = p -ᵥ p₂ | Given a point in an affine subspace, a vector is in its direction if and only if it results from
subtracting that point on the left. | true |
DirectSum.SetLike.IsHomogeneous | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
(ℳ : ι → σ) → [DirectSum.Decomposition ℳ] → {P : Type u_5} → [SetLike P M] → P → Prop | A substructure `p ⊆ M` is homogeneous if for every `m ∈ p`, all homogeneous components
of `m` are in `p`. | true |
Subalgebra.finrank_right_dvd_finrank_sup_of_free | Mathlib.Algebra.Algebra.Subalgebra.Rank | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A B : Subalgebra R S)
[Module.Free R ↥B] [Module.Free ↥B ↥(Algebra.adjoin ↥B ↑A)], Module.finrank R ↥B ∣ Module.finrank R ↥(A ⊔ B) | null | true |
MulOpposite.instNonUnitalNormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : NonUnitalNormedRing α] (a b : αᵐᵒᵖ), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
Graded.subtypeMap | Mathlib.Data.FunLike.Graded | {F : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : FunLike F A B] → [GradedFunLike F 𝒜 ℬ] →... | A graded map descends to a map on each component. | true |
smoothSheafCommGroup.compLeft | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_2} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_3} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_4} →
... | For a manifold `M` and a smooth homomorphism `φ` between abelian Lie groups `A`, `A'`, the
'left-composition-by-`φ`' morphism of sheaves from `smoothSheafCommGroup IM I M A` to
`smoothSheafCommGroup IM I' M A'`. | true |
Batteries.BinomialHeap.Imp.Heap.foldTreeM._f | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
{α : Type u_3} →
[Monad m] →
β → (α → β → β → m β) → (x : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.below x → m β | null | false |
Representation.mapSubmodule._proof_15 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_3} {G : Type u_2} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (q : Submodule (MonoidAlgebra k G) ρ.asModule),
(fun p =>
let __AddSubmonoid := AddSubmonoid.map ρ.asModuleEquiv.symm (↑p).toAddSubmonoid;
... | null | false |
Prod.instSubsingletonUnits | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : Monoid M] [inst_1 : Monoid N] [Subsingleton Mˣ] [Subsingleton Nˣ],
Subsingleton (M × N)ˣ | null | true |
LieDerivation.coe_sub_linearMap | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(D1 D2 : LieDerivation R L M), ↑(D1 - D2) = ↑D1 - ↑D2 | null | true |
UInt32.ofBitVec_mod | Init.Data.UInt.Lemmas | ∀ (a b : BitVec 32), { toBitVec := a % b } = { toBitVec := a } % { toBitVec := b } | null | true |
Aesop.instInhabitedRule.default | Aesop.Rule.Basic | {α : Type} → [Inhabited α] → Aesop.Rule α | null | true |
Std.ExtHashMap.getKey?_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m₁ ∩ m₂).getKey? k = if k ∈ m₂ then m₁.getKey? k else none | null | true |
CategoryTheory.CartesianMonoidalCategory.mono_lift_of_mono_right | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Mono g],
CategoryTheory.Mono (CategoryTheory.CartesianMonoidalCategory.lift f g) | null | true |
Lean.Lsp.SemanticTokenType.decorator.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.decorator = 1 | null | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Icc_div._proof_1_9 | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_1} [inst : CommGroup M] {n : ℕ} {a b : Fin n} (f : Fin (n + 1) → M) (x : ℕ),
↑a ≤ x ∧ x ≤ ↑b →
(if h : x < n then f ⟨x + 1, ⋯⟩ / f ⟨x, ⋯⟩ else 1) =
(if h : x < n then f ⟨x + 1, ⋯⟩ else 1) / if h : x ≤ n then f ⟨x, ⋯⟩ else 1 | null | false |
_private.Lean.Elab.AssertExists.0.Lean.Elab.Command.elabImportPath._regBuiltin.Lean.Elab.Command.elabImportPath_1 | Lean.Elab.AssertExists | IO Unit | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceXOr.declare_73._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.370586403._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Subgroup.rightCosetEquivSubgroup.eq_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} (g : α),
Subgroup.rightCosetEquivSubgroup g =
{ toFun := fun x => ⟨↑x * g⁻¹, ⋯⟩, invFun := fun x => ⟨↑x * g, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } | null | true |
CategoryTheory.Localization.Lifting₂.ctorIdx | Mathlib.CategoryTheory.Localization.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D₁ : Type u_3} →
{D₂ : Type u_4} →
{E : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} D₁} →
{inst_3 ... | null | false |
_private.Mathlib.Algebra.Polynomial.Degree.Defs.0.Polynomial.degree_le_iff_coeff_zero._simp_1_2 | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
(s.sup f ≤ a) = ∀ b ∈ s, f b ≤ a | null | false |
List.takeWhile_cons_of_pos | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, p a = true → List.takeWhile p (a :: l) = a :: List.takeWhile p l | null | true |
_private.Mathlib.Topology.Connected.Clopen.0.nonempty_frontier_iff._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) | null | false |
Lean.Expr.const.injEq | Lean.Expr | ∀ (declName : Lean.Name) (us : List Lean.Level) (declName_1 : Lean.Name) (us_1 : List Lean.Level),
(Lean.Expr.const declName us = Lean.Expr.const declName_1 us_1) = (declName = declName_1 ∧ us = us_1) | null | true |
Array.getElem_setIfInBounds | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {j : ℕ} (hj : j < xs.size),
(xs.setIfInBounds i a)[j] = if i = j then a else xs[j] | null | true |
SimpleGraph.IsClique.of_induce | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {S : G.Subgraph} {F : Set α} {A : Set ↑F},
(S.induce F).coe.IsClique A → G.IsClique (Subtype.val '' A) | If a set of vertices `A` is a clique in subgraph of `G` induced by a superset of `A`,
its embedding is a clique in `G`. | true |
ULift.seminormedCommRing._proof_15 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (n : ℕ) (a : ULift.{u_1, u_2} α),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | null | false |
_private.Mathlib.Algebra.Category.Grp.Basic.0.CommGrpCat.Hom.mk._flat_ctor | Mathlib.Algebra.Category.Grp.Basic | {A B : CommGrpCat} → (↑A →* ↑B) → A.Hom B | null | false |
Prod.instExistsAddOfLE | Mathlib.Algebra.Order.Monoid.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] [inst_2 : Add α] [inst_3 : Add β] [ExistsAddOfLE α]
[ExistsAddOfLE β], ExistsAddOfLE (α × β) | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrMFast.loop._unary._proof_2 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (n_usize : USize),
n_usize.toNat = n → ∀ (i : USize), i.toNat ≤ n → 0 < i.toNat → (i - 1).toNat = i.toNat - 1 → (i - 1).toNat < n | null | false |
NonarchAddGroupNorm.rec | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : NonarchAddGroupNorm G → Sort u} →
((toNonarchAddGroupSeminorm : NonarchAddGroupSeminorm G) →
(eq_zero_of_map_eq_zero' : ∀ (x : G), toNonarchAddGroupSeminorm.toFun x = 0 → x = 0) →
motive
{ toNonarchAddGroupSeminorm := toNon... | null | false |
exteriorPower.pairingDual | Mathlib.LinearAlgebra.ExteriorPower.Pairing | (R : Type u_1) →
(M : Type u_2) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (n : ℕ) → ↥(⋀[R]^n (Module.Dual R M)) →ₗ[R] Module.Dual R ↥(⋀[R]^n M) | The linear map from the exterior power of the dual to the dual of the exterior power. | true |
Ordinal.cof_eq | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ (α : Type u) [inst : Preorder α], ∃ s, IsCofinal s ∧ Cardinal.mk ↑s = Order.cof α | **Alias** of `Order.cof_eq`. | true |
Std.DHashMap.Internal.Raw₀.Const.get_modify | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} [inst_2 : EquivBEq α] [inst_3 : LawfulHashable α]
(m : Std.DHashMap.Internal.Raw₀ α fun x => β) (h : (↑m).WF) {k k' : α} {f : β → β}
(hc : (Std.DHashMap.Internal.Raw₀.Const.modify m k f).contains k' = true),
Std.DHashMap.Internal.Raw₀.Const.get (Std... | null | true |
basis_toMatrix_basisFun_mul | Mathlib.LinearAlgebra.Matrix.Basis | ∀ {ι : Type u_1} {R : Type u_5} [inst : CommSemiring R] [inst_1 : Fintype ι] (b : Module.Basis ι R (ι → R))
(A : Matrix ι ι R), b.toMatrix ⇑(Pi.basisFun R ι) * A = Matrix.of fun i j => (b.repr (A.col j)) i | null | true |
CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | `ReflectsCofilteredLimitsOfSize.{w', w} F` means that whenever the image of a cofiltered cone
under `F` is a limit cone, the original cone was already a limit. | true |
_private.Init.Data.Array.Range.0.Array.mem_range'_1._simp_1_1 | Init.Data.Array.Range | ∀ {s step m n : ℕ}, (m ∈ Array.range' s n step) = ∃ i < n, m = s + step * i | null | false |
SemiconjBy.op | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Mul α] {a x y : α},
SemiconjBy a x y → SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x) | null | true |
Lean.Order.MonadTail.monotone_bind_right | Init.Internal.Order.MonadTail | ∀ (m : Type u → Type v) [inst : Monad m] [inst_1 : Lean.Order.MonadTail m] {α β : Type u} [inst_2 : Nonempty β]
{γ : Sort w} [inst_3 : Lean.Order.PartialOrder γ] (f : m α) (g : γ → α → m β),
Lean.Order.monotone g → Lean.Order.monotone fun x => f >>= g x | null | true |
Std.Internal.Small.mk._flat_ctor | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type v}, Nonempty (Std.Internal.ComputableSmall α) → Std.Internal.Small α | null | false |
Finset.nonempty_product | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty | null | true |
MonoidAlgebra.mapDomainNonUnitalRingHom_comp | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} {O : Type u_8} [inst : Semiring R] [inst_1 : Mul M] [inst_2 : Mul N]
[inst_3 : Mul O] (f : N →ₙ* O) (g : M →ₙ* N),
MonoidAlgebra.mapDomainNonUnitalRingHom R (f.comp g) =
(MonoidAlgebra.mapDomainNonUnitalRingHom R f).comp (MonoidAlgebra.mapDomainNonUnitalRingHom R g... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Find.Char.0.String.Slice.find?_char_eq_some_iff._proof_1_1 | Init.Data.String.Lemmas.Pattern.Find.Char | ∀ {s : String.Slice} {pos : s.Pos}, ¬pos = s.endPos → ¬pos = s.endPos | null | false |
OrderMonoidHom.copy._proof_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
[inst_3 : MulOneClass β] (f : α →*o β) (f' : α → β) (h : f' = ⇑f) (x y : α),
(↑(f.copy f' h)).toFun (x * y) = (↑(f.copy f' h)).toFun x * (↑(f.copy f' h)).toFun y | null | false |
Lean.Elab.Term.MatchAltView.mk.inj | Lean.Elab.MatchAltView | ∀ {k : Lean.SyntaxNodeKinds} {ref : Lean.Syntax} {patterns : Array Lean.Syntax} {lhs : Lean.Syntax}
{rhs : Lean.TSyntax k} {ref_1 : Lean.Syntax} {patterns_1 : Array Lean.Syntax} {lhs_1 : Lean.Syntax}
{rhs_1 : Lean.TSyntax k},
{ ref := ref, patterns := patterns, lhs := lhs, rhs := rhs } =
{ ref := ref_1, pat... | null | true |
WithZeroTopology.tendsto_of_ne_zero | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {l : Filter α} {f : α → Γ₀} {γ : Γ₀},
γ ≠ 0 → (Filter.Tendsto f l (nhds γ) ↔ ∀ᶠ (x : α) in l, f x = γ) | null | true |
CategoryTheory.Functor.CoreMonoidal.toLaxMonoidal.eq_1 | Mathlib.CategoryTheory.Monoidal.Braided.Transport | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} (h : F.CoreMonoidal),
h.toLaxMonoidal =
{ ε := h.εIso.hom, μ := fun... | null | true |
NumberField.mixedEmbedding.norm_le_convexBodySumFun | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.mixedSpace K),
‖x‖ ≤ NumberField.mixedEmbedding.convexBodySumFun x | null | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.X | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} → {S : C} → (self : F.PreOneHypercoverDenseData S) → self.I₀ → C₀ | the objects in the covering of `S` | true |
Std.HashSet.any_eq_true_iff_exists_mem_get | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [LawfulHashable α] [EquivBEq α] {p : α → Bool},
m.any p = true ↔ ∃ a, ∃ (h : a ∈ m), p (m.get a h) = true | null | true |
Int.cast_natCast | Mathlib.Data.Int.Cast.Basic | ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℕ), ↑↑n = ↑n | null | true |
Asymptotics.IsBigO.integrableAtFilter | Mathlib.MeasureTheory.Integral.Asymptotics | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] {f : α → E} {g : α → F} {l : Filter α}
[inst_1 : MeasurableSpace α] [inst_2 : NormedAddCommGroup F] {μ : MeasureTheory.Measure α} [l.IsMeasurablyGenerated],
f =O[l] g →
StronglyMeasurableAtFilter f l μ → MeasureTheory.IntegrableAtFilte... | If `f = O[l] g` on measurably generated `l`, `f` is strongly measurable at `l`,
and `g` is integrable at `l`, then `f` is integrable at `l`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.