name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.IsAddFundamentalDomain.integral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α]
[MeasureTheory.VAddInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
MeasureT... | null | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.rotate_eq_iff | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {n : ℕ} {x y : BitVec n}, BitVec.Signed.rotate✝ x = y ↔ x = BitVec.Signed.rotate✝ y | null | true |
Std.DHashMap.Internal.Raw₀.equiv_emptyWithCapacity_iff_isEmpty | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF → ∀ {c : ℕ}, (↑m).Equiv ↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity c) ↔ (↑m).isEmpty = true | null | true |
LinearEquiv.automorphismGroup.toLinearMapMonoidHom._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x x_1 : M ≃ₗ[R] M), ↑(x * x_1) = ↑(x * x_1) | null | false |
Mathlib.Tactic.ClickSuggestions.ApplyKey._sizeOf_1 | Mathlib.Tactic.ClickSuggestions.Apply | Mathlib.Tactic.ClickSuggestions.ApplyKey → ℕ | 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 |
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 |
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 |
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 |
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 |
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 |
_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 |
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 |
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.NumberTheory.Transcendental.Liouville.Measure.0.setOfPred_liouvilleWith_subset_aux._simp_1_8 | Mathlib.NumberTheory.Transcendental.Liouville.Measure | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (c ≤ a + -b) = (c + b ≤ a) | null | false |
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 |
Lean.Parser.Term.completion.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalIte._sparseCasesOn_8 | Mathlib.Tactic.Positivity.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
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 |
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 |
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 |
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 |
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 |
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 |
_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 |
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} α), ↑n.succ • a = ↑n • a + a | null | false |
_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 |
OrderSupSet.noConfusion | Mathlib.Order.Bounds.Defs | {P : Sort u} →
{α : Type u_2} →
{inst : LE α} →
{t : OrderSupSet α} →
{α' : Type u_2} →
{inst' : LE α'} → {t' : OrderSupSet α'} → α = α' → inst ≍ inst' → t ≍ t' → OrderSupSet.noConfusionType P t t' | 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 |
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 |
_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 |
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 |
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 |
SkewMonoidAlgebra.liftNCAlgHom | Mathlib.Algebra.SkewMonoidAlgebra.Lift | {k : Type u_1} →
{G : Type u_2} →
[inst : CommSemiring k] →
[inst_1 : Monoid G] →
{A : Type u_4} →
{B : Type u_5} →
[inst_2 : Semiring A] →
[inst_3 : Algebra k A] →
[inst_4 : Semiring B] →
[inst_5 : Algebra k B] →
... | `liftNCRingHom` as an `AlgHom`, for when `f` is an `AlgHom` | true |
Real.sin_two_mul | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sin (2 * x) = 2 * Real.sin x * Real.cos x | null | true |
CategoryTheory.Limits.hasColimit_of_coequalizer_and_coproduct | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor F.obj)]
[CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun f => F.obj f.fst.1)]
[C... | Given the existence of the appropriate (possibly finite) coproducts and coequalizers,
we know a colimit of `F` exists.
(This assumes the existence of all coequalizers, which is technically stronger than needed.)
| true |
AddGroupConeClass | Mathlib.Algebra.Order.Group.Cone | (S : Type u_1) → (G : outParam (Type u_2)) → [AddCommGroup G] → [SetLike S G] → Prop | `AddGroupConeClass S G` says that `S` is a type of cones in `G`. | true |
_private.Lean.LibrarySuggestions.SineQuaNon.0.Lean.LibrarySuggestions.SineQuaNon.initFn._@.Lean.LibrarySuggestions.SineQuaNon.830398421._hygCtx._hyg.2 | Lean.LibrarySuggestions.SineQuaNon | IO (Lean.SimplePersistentEnvExtension Lean.Name Lean.NameSet) | null | false |
Profinite.NobelingProof.spanCone._proof_4 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} {C : Set (I → Bool)}, TotallyDisconnectedSpace { x // x ∈ C } | null | false |
List.twoStepInduction._proof_2 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x y : α) (xs : List α), (invImage (fun x => x) sizeOfWFRel).1 xs (x :: y :: xs) | null | false |
isClosed_empty | Mathlib.Topology.Basic | ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed ∅ | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.isValidPercentEncoding._proof_1 | Std.Http.Data.URI.Encoding | ∀ (ba : ByteArray) (i : ℕ), i + 2 < ba.size → ¬i + 1 < ba.size → False | null | false |
AddChar.zmodAddEquiv._proof_3 | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {n : ℕ} [inst : NeZero n],
Function.Bijective ⇑(AddChar.circleEquivComplex.toAddMonoidHom.comp AddChar.zmodHom.toAddMonoidHom) | null | false |
Lean.Elab.Term.CollectPatternVars.Context.newArgs | Lean.Elab.PatternVar | Lean.Elab.Term.CollectPatternVars.Context → Array Lean.Term | null | true |
NegMemClass.neg | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_5} → {S : Type u_6} → [inst : Neg G] → [inst_1 : SetLike S G] → [NegMemClass S G] → {H : S} → Neg ↥H | An additive subgroup of an `AddGroup` inherits an inverse. | true |
Lean.Elab.Term.PostponeBehavior.ctorElimType | Lean.Elab.SyntheticMVars | {motive : Lean.Elab.Term.PostponeBehavior → Sort u} → ℕ → Sort (max 1 u) | null | false |
ModuleCat.hom_whiskerLeft | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommRing R] (L : ModuleCat R) {M N : ModuleCat R} (f : M ⟶ N),
ModuleCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.whiskerLeft L f) =
LinearMap.lTensor (↑L) (ModuleCat.Hom.hom f) | null | true |
IsLocalization.orderIsoOfMaximal._proof_7 | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (y : R) [inst_2 : Algebra R S]
[inst_3 : IsLocalization.Away y S] [inst_4 : IsJacobsonRing R] (x : { p // p.IsMaximal ∧ y ∉ p }),
⟨Ideal.comap (algebraMap R S) ↑⟨Ideal.map (algebraMap R S) ↑x, ⋯⟩, ⋯⟩ = x | null | false |
CategoryTheory.InjectiveResolution.desc.eq_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y)
(I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z),
CategoryTheory.InjectiveResolution.desc f I J =
J.cocomplex.mkHom I.cocomplex (CategoryTheory.InjectiveResolut... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.exists_isPath_forall_isPath_length_le_length.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} (G : SimpleGraph V) (n : ℕ),
let s := {n | ∃ u v p, p.IsPath ∧ p.length = n};
∀ (motive : n ∈ s → Prop) (x : n ∈ s),
(∀ (w w_1 : V) (w_2 : G.Walk w w_1) (hp : w_2.IsPath) (hn : w_2.length = n), motive ⋯) → motive x | null | false |
Aesop.ForwardClusterStateStats.casesOn | Aesop.Stats.Basic | {motive : Aesop.ForwardClusterStateStats → Sort u} →
(t : Aesop.ForwardClusterStateStats) →
((slots : ℕ) →
(instantiationStats : Array Aesop.ForwardInstantiationStats) →
motive { slots := slots, instantiationStats := instantiationStats }) →
motive t | null | false |
HahnSeries.isPWO_support._simp_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R), x.support.IsPWO = True | null | false |
Primcodable.subtype._proof_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop} [inst_1 : DecidablePred p] (n : ℕ),
Encodable.encode ((Encodable.decode n).bind fun a => Option.guard (fun b => decide (p b)) a) =
Encodable.encode ((Encodable.decode n).bind fun x => if h : p x then some ⟨x, h⟩ else none) | null | false |
Equiv.withBotCongr_refl | Mathlib.Order.WithBot | ∀ {α : Type u_1}, (Equiv.refl α).withBotCongr = Equiv.refl (WithBot α) | null | true |
SeparationQuotient.lift.congr_simp | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {α : Type u_4} [inst : TopologicalSpace X] (f f_1 : X → α) (e_f : f = f_1)
(hf : ∀ (x y : X), Inseparable x y → f x = f y) (a a_1 : SeparationQuotient X),
a = a_1 → SeparationQuotient.lift f hf a = SeparationQuotient.lift f_1 ⋯ a_1 | null | true |
ae_restrict_le_codiscreteWithin | Mathlib.MeasureTheory.Topology | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
{μ : MeasureTheory.Measure α} [MeasureTheory.NullSingletonClass μ] {U : Set α},
MeasurableSet U → MeasureTheory.ae (μ.restrict U) ≤ Filter.codiscreteWithin U | Under reasonable assumptions, sets that are codiscrete within `U` are contained in the "almost
everywhere" filter of co-null sets. | true |
instNonUnitalCStarAlgebraSubtypePreLpMemAddSubgroupLpTopENNReal._proof_3 | Mathlib.Analysis.CStarAlgebra.lpSpace | ∀ {I : Type u_1} {A : I → Type u_2} [inst : (i : I) → NonUnitalCStarAlgebra (A i)], CStarRing ↥(lp A ⊤) | null | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_19 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → ¬a = x → a ∈ y :: tail | null | false |
FreeRing.castFreeCommRing.eq_1 | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u_1}, FreeRing.castFreeCommRing = ⇑FreeRing.toFreeCommRing | null | true |
Std.Time.Internal.Bounded.LE.toFin._proof_2 | Std.Time.Internal.Bounded | ∀ {lo hi : ℤ} (n : Std.Time.Internal.Bounded.LE lo hi), 0 ≤ lo → 0 ≤ hi + 1 | null | false |
String.Slice.Pos.apply_revSkipWhile_prop._proof_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String.Slice} {pos : s.Pos} {h : pos.revSkipWhile P ≠ s.startPos},
(pos.revSkipWhile P).prev h ≠ s.endPos | null | false |
CategoryTheory.MonoidalClosed.uncurry_ihomCurry | Mathlib.CategoryTheory.Monoidal.Closed.InternalCurrying | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (x y z : C)
[inst_2 : CategoryTheory.Closed x] [inst_3 : CategoryTheory.Closed y]
[inst_4 : CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)],
CategoryTheory.MonoidalClosed.uncurry (Cat... | null | true |
WithBot.instIsOrderedAddMonoid | Mathlib.Algebra.Order.Monoid.WithTop | ∀ {α : Type u} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α], IsOrderedAddMonoid (WithBot α) | null | true |
MeasurableSpace.mapNatBool | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | (α : Type u_1) → [inst : MeasurableSpace α] → [MeasurableSpace.CountablyGenerated α] → α → ℕ → Bool | A map from a measurable space to the Cantor space `ℕ → Bool` induced by a countable
sequence of sets generating the measurable space. | true |
UniqueFactorizationMonoid.toNormalizedGCDMonoid._proof_8 | Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid | ∀ (α : Type u_1) [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [inst_2 : NormalizationMonoid α]
(a b : α), (Associates.mk a ⊓ Associates.mk b).out ∣ b | null | false |
BitVec.extractLsb_xor | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {y x : BitVec w} {hi lo : ℕ},
BitVec.extractLsb lo hi (x ^^^ y) = BitVec.extractLsb lo hi x ^^^ BitVec.extractLsb lo hi y | null | true |
IsNilpotent.of_pow | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_3} [inst : MonoidWithZero R] {x : R} {m : ℕ}, IsNilpotent (x ^ m) → IsNilpotent x | null | true |
CommRingCat.piFanIsLimit | Mathlib.Algebra.Category.Ring.Constructions | {ι : Type u} → (R : ι → CommRingCat) → CategoryTheory.Limits.IsLimit (CommRingCat.piFan R) | The categorical product of rings is the Cartesian product of rings.
| true |
DirectSum.fromAddMonoid | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → (DirectSum ι fun i => γ →+ β i) →+ γ →+ DirectSum ι fun i => β i | `fromAddMonoid φ` is the natural homomorphism from `γ` to `⨁ i, β i`
induced by a family `φ` of homomorphisms `γ → β i`.
Note that this is not an isomorphism. Not every homomorphism `γ →+ ⨁ i, β i` arises in this way. | true |
IsUnit.eq_one | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {a : M} [Subsingleton Mˣ], IsUnit a → a = 1 | null | true |
ValuativeRel.exists_valuation_posSubmonoid_div_valuation_posSubmonoid_eq | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : ValuativeRel R] (γ : (ValuativeRel.ValueGroupWithZero R)ˣ),
∃ a b, (ValuativeRel.valuation R) ↑a / (ValuativeRel.valuation R) ↑b = ↑γ | null | true |
Unitary.map_comp | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S]
[inst_3 : StarMul S] [inst_4 : Monoid T] [inst_5 : StarMul T] (g : S →⋆* T) (f : R →⋆* S),
Unitary.map (g.comp f) = (Unitary.map g).comp (Unitary.map f) | null | true |
Finset.centerMass_pair | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} {ι : Type u_5} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(i j : ι) (w : ι → R) (z : ι → E) [inst_3 : DecidableEq ι],
i ≠ j → {i, j}.centerMass w z = (w i / (w i + w j)) • z i + (w j / (w i + w j)) • z j | null | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.CollectDerivedValInfo.collect | Lean.Compiler.LCNF.ExplicitRC | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure →
Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.DerivedValMap✝ × Lean.FVarIdHashSet) | Collect the derived value tree as well as the set of parameters that take objects and are borrowed.
| true |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_5 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | { obj := fun G => G.toProfinite,
map := fun {X Y} f =>
CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X)
{ toFun := ⇑(ProfiniteAddGrp.Hom.hom f), continuous_toFun := ⋯ },
map_id :=
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnected... | null | false |
Mathlib.Tactic.Ring.CSLift.ctorIdx | Mathlib.Tactic.Ring.Basic | {α : Type u} → {β : outParam (Type u)} → Mathlib.Tactic.Ring.CSLift α β → ℕ | null | false |
GaloisConnection.toGaloisCoinsertion.eq_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(gc : GaloisConnection u l) (h : ∀ (b : β), l (u b) ≤ b),
gc.toGaloisCoinsertion h = { choice := fun x x_1 => l x, gc := gc, u_l_le := h, choice_eq := ⋯ } | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.