name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.instToJsonReferenceContext.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → Lean.Json | null | true |
SSet.stdSimplexToTop.eq_1 | Mathlib.AlgebraicTopology.SingularHomology.Basic | SSet.stdSimplexToTop =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerLeft SSet.stdSimplex sSetTopAdj.unit)
(CategoryTheory.Functor.whiskerRight SSet.toTopSimplex.hom TopCat.toSSet) | null | true |
LeanSearchClient.just_loogle_cmd | LeanSearchClient.LoogleSyntax | Lean.ParserDescr | Search [Loogle](https://loogle.lean-lang.org/json) from within Lean. This can be used as a command, term or tactic as in the following examples. In the case of a tactic, only valid tactics are displayed.
```lean
#loogle List ?a → ?a
example := #loogle List ?a → ?a
example : 3 ≤ 5 := by
#loogle Nat.succ_le_succ
... | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.mkH1OfIsTrivial._simp_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f x + f y = f (x + y) | null | false |
AddOreLocalization.addOreSetComm_oreSubtra | Mathlib.GroupTheory.OreLocalization.OreSet | ∀ {R : Type u_2} [inst : AddCommMonoid R] (S : AddSubmonoid R) (r : R) (s : ↥S), AddOreLocalization.oreSubtra r s = s | null | true |
Complex.exp_neg | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℂ), Complex.exp (-x) = (Complex.exp x)⁻¹ | null | true |
RatFunc.num_mul_eq_mul_denom_iff | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] {x : RatFunc K} {p q : Polynomial K},
q ≠ 0 →
(x.num * q = p * x.denom ↔
x = (algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q) | null | true |
Std.TreeMap.Raw.Equiv.insertIfNew | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (k : α) (v : β), (t₁.insertIfNew k v).Equiv (t₂.insertIfNew k v) | null | true |
Condensed.isoFinYoneda._proof_3 | Mathlib.Condensed.Discrete.Colimit | ∀ (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u_1 + 1))) [inst : CategoryTheory.Limits.PreservesFiniteProducts F]
{X Y : FintypeCatᵒᵖ} (x : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((FintypeCat.toProfinite.op.comp F).map x)
(Condensed.isoFinYonedaComponents F (FintypeCat.toProfinite.obj (Opposite.unop Y)... | null | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.bindCases.go.match_3.splitter | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Code.return fvarId)) →
((x : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
(∀ (fvarId : Lea... | null | true |
SSet.instNonemptyObjSimplexCategoryStdSimplex | Mathlib.AlgebraicTopology.SimplicialSet.Nonempty | ∀ (n : SimplexCategory), (SSet.stdSimplex.obj n).Nonempty | null | true |
Prod.instOmegaCompletePartialOrder._proof_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_1} {β : Type u_2} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(x : OmegaCompletePartialOrder.Chain (α × β)) (x_1 : α × β),
(∀ (i : ℕ), x i ≤ x_1) → (Prod.ωSupImpl x).1 ≤ x_1.1 ∧ (Prod.ωSupImpl x).2 ≤ x_1.2 | null | false |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.extract.go₁_cons_addChar._simp_1_4 | Batteries.Data.String.Lemmas | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | null | false |
VonNeumannAlgebra.mem_commutant_iff._simp_1 | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] [inst_2 : CompleteSpace H]
{S : VonNeumannAlgebra H} {z : H →L[ℂ] H}, (z ∈ S.commutant) = ∀ g ∈ S, g * z = z * g | null | false |
Nucleus.instHImp._proof_7 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (m n : Nucleus X) (y : X), m (m y ⇨ n y) ⇨ n (m y ⇨ n y) = m y ⇨ n y | null | false |
AddGrpCat.limitAddGroup._aux_1 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J AddGrpCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddGrpCat)).sections] →
(CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddGrpCat))).pt | null | false |
Subsemigroup.toAddSubsemigroup._proof_3 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (S : AddSubsemigroup (Additive M)) {a b : M},
a ∈ S.carrier → b ∈ S.carrier → a + b ∈ S.carrier | null | false |
ContinuousMultilinearMap.apply._proof_2 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_1) {ι : Type u_2} (E : ι → Type u_3) (F : Type u_4) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopological... | null | false |
Aesop.GoalRef.checkAndMarkUnprovable | Aesop.Tree.State | Aesop.GoalRef → BaseIO Unit | null | true |
CategoryTheory.CatEnriched.instBicategory._proof_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_2} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b c d : CategoryTheory.CatEnriched C}
(f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g ... | null | false |
Cardinal.toNat_eq_of_forall_le_iff | Mathlib.SetTheory.Cardinal.ToNat | ∀ {c : Cardinal.{u}} {d : Cardinal.{v}}, (∀ (n : ℕ), ↑n ≤ c ↔ ↑n ≤ d) → Cardinal.toNat c = Cardinal.toNat d | A `Cardinal.toNat` version of `eq_of_forall_le_iff`.
This is useful for proving equality of `Module.finrank`. | true |
Std.HashMap.Raw.getElem?_alter_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k : α} {f : Option β → Option β}, m.WF → (m.alter k f)[k]? = f m[k]? | null | true |
CategoryTheory.IsMonoidalLeftDistrib.mk | Mathlib.CategoryTheory.Distributive.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C],
autoParam
(∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)
(Cate... | null | true |
Std.HashMap.Raw.getKey?_eq_some_of_contains | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, m.contains k = true → m.getKey? k = some k | null | true |
IsLowerModularLattice.inf_covBy_of_covBy_sup | Mathlib.Order.ModularLattice | ∀ {α : Type u_2} {inst : Lattice α} [self : IsLowerModularLattice α] {a b : α}, a ⋖ a ⊔ b → a ⊓ b ⋖ b | `a` and `b` both cover `a ⊓ b` if `a ⊔ b` covers either `a` or `b` | true |
Std.TreeMap.contains_minKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{he : t.isEmpty = false}, t.contains (t.minKey he) = true | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Basic.0.Right.inv_nonneg._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {a : G₀},
(0 < a⁻¹) = (0 < a) | null | false |
LieModule.trivialIsNilpotent | Mathlib.Algebra.Lie.Nilpotent | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M]
[LieModule.IsTrivial L M], LieModule.IsNilpotent L M | null | true |
IsConj.pow | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : Monoid α] {a b : α} (n : ℕ), IsConj a b → IsConj (a ^ n) (b ^ n) | null | true |
ComplexShape.instIsTruncLENatIntEmbeddingDownNat | Mathlib.Algebra.Homology.Embedding.Basic | ComplexShape.embeddingDownNat.IsTruncLE | null | true |
Function.Injective.mulAction.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} {β : Type u_6} [inst : Monoid M] [inst_1 : MulAction M α] [inst_2 : SMul M β]
(f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c • x) = c • f x),
Function.Injective.mulAction f hf smul = { toSMul := inst_2, mul_smul := ⋯, one_smul := ⋯ } | null | true |
Std.DTreeMap.Const.getThenInsertIfNew?_fst | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k : α}
{v : β}, (Std.DTreeMap.Const.getThenInsertIfNew? t k v).1 = Std.DTreeMap.Const.get? t k | null | true |
HasFiniteFPowerSeriesAt.comp | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [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] {m n : ℕ} {g : F → G} {f : E → F}
{... | If two functions `g` and `f` have finite power series `q` and `p` respectively at `f x` and `x`,
then `g ∘ f` admits the finite power series `q.comp p` at `x`. | true |
_private.Mathlib.RingTheory.Finiteness.Basic.0.Submodule.fg_pi._simp_1_1 | Mathlib.RingTheory.Finiteness.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M}, N.FG = ∃ S, S.Finite ∧ Submodule.span R S = N | null | false |
Convex.quasiconcaveOn_restrict | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_4} {E : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {β : Type u_6} [inst_4 : Preorder β] {s : Set E} {f : E → β} {t : Set E},
QuasiconcaveOn 𝕜 s f → t ⊆ s → Convex 𝕜 t → QuasiconcaveOn 𝕜 t f | null | true |
MeasureTheory.NullMeasurable.congr | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {β : Type u_3} [m : MeasurableSpace α] [inst : MeasurableSpace β] {f : α → β}
{μ : MeasureTheory.Measure α} {g : α → β},
MeasureTheory.NullMeasurable f μ → f =ᵐ[μ] g → MeasureTheory.NullMeasurable g μ | null | true |
_private.Init.Data.UInt.Lemmas.0.USize.toUInt64_eq_mod_usizeSize_iff._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a = b) = (a.toNat = b.toNat) | null | false |
Std.ExtDHashMap.getKey?_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.ExtDHashMap.filterMap f m).getKey? k = (m.getKey? k).pfilter fun x_2 h' => (f x_2 (m.get x_2 ⋯)).isSome | null | true |
_private.Mathlib.Combinatorics.Configuration.0.Configuration.ofField.instProjectivePlaneProjectivizationForallFinOfNatNatOfDecidableEq._simp_2 | Mathlib.Combinatorics.Configuration | ∀ {F : Type u_1} [inst : Field F] {m : Type u_2} [inst_1 : Fintype m] {v w : m → F} (hv : v ≠ 0) (hw : w ≠ 0),
(Projectivization.mk F v hv).orthogonal (Projectivization.mk F w hw) = (v ⬝ᵥ w = 0) | null | false |
_private.Lean.Meta.ExprLens.0.Lean.Meta.lensAux._unsafe_rec | Lean.Meta.ExprLens | {M : Type → Type} →
[Monad M] →
[MonadLiftT Lean.MetaM M] →
[MonadControlT Lean.MetaM M] → [Lean.MonadError M] → (Lean.Expr → M Lean.Expr) → List ℕ → Lean.Expr → M Lean.Expr | null | false |
DistribMulActionHom.ctorIdx | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
{inst : Monoid M} →
{N : Type u_2} →
{inst_1 : Monoid N} →
{φ : M →* N} →
{A : Type u_10} →
{inst_2 : AddMonoid A} →
{inst_3 : DistribMulAction M A} →
{B : Type u_11} → {inst_4 : AddMonoid B} → {inst_5 : DistribMulAction N B} → (A ... | null | false |
Matrix.ext_iff_vecMul | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype m] {A B : Matrix m n α},
A = B ↔ ∀ (v : m → α), Matrix.vecMul v A = Matrix.vecMul v B | null | true |
WeierstrassCurve.ext | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} {x y : WeierstrassCurve R}, x.a₁ = y.a₁ → x.a₂ = y.a₂ → x.a₃ = y.a₃ → x.a₄ = y.a₄ → x.a₆ = y.a₆ → x = y | null | true |
IsBaseChange.basis_repr_comp_apply | Mathlib.RingTheory.TensorProduct.IsBaseChangeFree | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {V : Type u_3}
[inst_3 : AddCommMonoid V] [inst_4 : Module R V] {W : Type u_4} [inst_5 : AddCommMonoid W] [inst_6 : Module R W]
[inst_7 : Module S W] [inst_8 : IsScalarTower R S W] {ι : Type u_5} {ε : V →ₗ[R] W}... | null | true |
Metric.cthickening_of_nonpos | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ}, δ ≤ 0 → ∀ (E : Set α), Metric.cthickening δ E = closure E | null | true |
ContinuousAlternatingMap.nnnorm_ofSubsingleton_id | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ (𝕜 : Type u) (F : Type wF) {ι : Type v} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 F] [inst_4 : Subsingleton ι] [Nontrivial F] (i : ι),
‖(ContinuousAlternatingMap.ofSubsingleton 𝕜 F F i) (ContinuousLinearMap.id 𝕜 F)‖₊ = 1 | null | true |
CategoryTheory.isCardinalFiltered_iff' | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
CategoryTheory.IsCardinalFiltered J κ ↔
(∀ ⦃ι : Type w⦄ (j : ι → J), HasCardinalLT ι κ → ∃ k, ∀ (i : ι), Nonempty (j i ⟶ k)) ∧
∀ ⦃ι : Type w⦄ ⦃j k : J⦄ (f : ι → (j ⟶ k)),
HasCardinalLT ι κ → None... | Same as `isCardinalFiltered_iff`, but for the second condition involving
coequalizing morphisms, we assume that the index type `ι` is nonempty. | true |
Finset.disjoint_insert_right._simp_1 | Mathlib.Data.Finset.Disjoint | ∀ {α : Type u_2} [inst : DecidableEq α] {s t : Finset α} {a : α}, Disjoint s (insert a t) = (a ∉ s ∧ Disjoint s t) | null | false |
CategoryTheory.Comma.final_snd | Mathlib.CategoryTheory.Comma.Final | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) [CategoryTheory.IsFiltered A] [CategoryTheory.IsFiltered B] [R.Final],... | Let `A` and `B` be filtered categories, `R : B ⥤ T` be final and `R : A ⥤ T`. Then, the
projection `snd L R : Comma L R ⥤ B` is final. | true |
SSet.Subcomplex.N.opEquiv._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | ∀ {X : SSet} {A : X.Subcomplex} (x : A.op.N), x.simplex ∉ A.op.obj (Opposite.op { len := x.dim }) | null | false |
CategoryTheory.Presieve.overEquiv | Mathlib.CategoryTheory.Sites.Over | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → (Y : CategoryTheory.Over X) → CategoryTheory.Presieve Y ≃o CategoryTheory.Presieve Y.left | The equivalence `Presieve Y ≃ Presieve Y.left` for all `Y : Over X`. | true |
EuclideanGeometry.reflection_vadd_smul_vsub_orthogonalProjection | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] {s : AffineSubspace 𝕜 P}
[inst_5 : Nonempty ↥s] [inst_6 : s.direction.HasOrthogonalProjection] {p₁ : P} (p₂ : P) (r : 𝕜),
p... | Reflecting a vector plus a point in the subspace produces the
negation of that vector plus the point if the vector is a multiple of
the result of subtracting a point's orthogonal projection from that
point. | true |
KaehlerDifferential.kerTotal_map | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A : Type u_2)
(B : Type u_3) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra A B]
[inst_7 : Algebra S B] [inst_8 : Algebra R B] [IsScalarTower R A B] [IsScalarTower R S B],
Function.S... | Given the commutative diagram
```
A --→ B
↑ ↑
| |
R --→ S
```
The kernel of the presentation `⊕ₓ B dx ↠ Ω_{B/S}` is spanned by the image of the
kernel of `⊕ₓ A dx ↠ Ω_{A/R}` and all `ds` with `s : S`.
See `kerTotal_map'` for the special case where `R = S`.
| true |
Std.Do.SPred.down_pure | Std.Do.SPred.Laws | ∀ {φ : Prop}, ⌜φ⌝.down = φ | null | true |
Std.Broadcast.instReprError.repr | Std.Sync.Broadcast | Std.Broadcast.Error → ℕ → Std.Format | null | true |
QuadraticAlgebra.instAlgebra._proof_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {S : Type u_2} {a b : R} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra S R]
(s : S) (z : QuadraticAlgebra R a b),
{ toFun := fun s => QuadraticAlgebra.C ((algebraMap S R) s), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ }
s *
z =
z *
... | null | false |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.ensureType._sparseCasesOn_1 | Lean.Meta.LetToHave | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
ConnectedSpace.recOn | Mathlib.Topology.Connected.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{motive : ConnectedSpace α → Sort u_1} →
(t : ConnectedSpace α) →
([toPreconnectedSpace : PreconnectedSpace α] → (toNonempty : Nonempty α) → motive ⋯) → motive t | null | false |
Polynomial.toAddCircle.integrable | Mathlib.Analysis.Polynomial.Fourier | ∀ (p : Polynomial ℂ), MeasureTheory.Integrable (⇑(Polynomial.toAddCircle p)) AddCircle.haarAddCircle | null | true |
DerivedCategory.instHasShiftInt | Mathlib.Algebra.Homology.DerivedCategory.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : HasDerivedCategory C] → CategoryTheory.HasShift (DerivedCategory C) ℤ | null | true |
_private.Mathlib.CategoryTheory.Functor.OfSequence.0.CategoryTheory.Functor.OfSequence.map_comp._proof_1_12 | Mathlib.CategoryTheory.Functor.OfSequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (i : ℕ) {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1))
(hij : i + 1 ≤ 0) (hjk : 0 ≤ 0),
CategoryTheory.Functor.OfSequence.map f (i + 1) 0 ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OfSequence.map f (i + 1) 0 hij)
(CategoryTheo... | null | false |
Lean.Core.instMonadResolveNameCoreM | Lean.CoreM | Lean.MonadResolveName Lean.CoreM | null | true |
_private.Mathlib.Analysis.Analytic.CPolynomial.0.CPolynomialAt.add.match_1_1 | Mathlib.Analysis.Analytic.CPolynomial | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {g : E → F} {x : E}
(motive : CPolynomialAt 𝕜 g x → Prop) (hg : CPolynomialAt 𝕜 g x),
(∀ (w : FormalMultilin... | null | false |
_private.Lean.Meta.InferType.0.Lean.Meta.inferFVarType | Lean.Meta.InferType | Lean.FVarId → Lean.MetaM Lean.Expr | null | true |
Std.DTreeMap.Internal.Impl.le_minKeyD | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
t.isEmpty = false →
∀ {k fallback : α}, (compare k (t.minKeyD fallback)).isLE = true ↔ ∀ k' ∈ t, (compare k k').isLE = true | null | true |
String.Slice.toStringToString_eq | Init.Data.String.Slice | toString = String.Slice.copy | null | true |
Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | ∀ (lhs : ℕ) (rhs : Lean.Meta.Grind.CnstrRHS),
sizeOf (Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq lhs rhs) = 1 + sizeOf lhs + sizeOf rhs | null | true |
CommSemiRingCat.instCategory._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {W X Y Z : CommSemiRingCat} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_alter_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
AlgebraicTopology.DoldKan.homotopyPToId.eq_2 | Mathlib.AlgebraicTopology.DoldKan.HomotopyEquivalence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C) (q : ℕ),
AlgebraicTopology.DoldKan.homotopyPToId X q.succ =
(Homotopy.ofEq ⋯).trans
(((AlgebraicTopology.DoldKan.homotopyPToId X q).add
((AlgebraicTopo... | null | true |
Localization.mk_lt_mk | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelMonoid α] {s : Submonoid α}
{a₁ b₁ : α} {a₂ b₂ : ↥s}, Localization.mk a₁ a₂ < Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ < ↑a₂ * b₁ | null | true |
TwoSidedIdeal.coeAddMonoidHom._proof_1 | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R], AddSubmonoidClass (TwoSidedIdeal R) R | null | false |
Vector.back_mk._proof_2 | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} [NeZero n] {xs : Array α}, xs.size = n → 0 < xs.size | null | false |
Std.Do.PostShape.arg.sizeOf_spec | Std.Do.PostCond | ∀ (σ : Type u) (a : Std.Do.PostShape), sizeOf (Std.Do.PostShape.arg σ a) = 1 + sizeOf σ + sizeOf a | null | true |
csSup_image2_eq_csInf_csSup | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [inst_2 : ConditionallyCompleteLattice γ] {s : Set α} {t : Set β}
{l : α → β → γ} {u₁ : β → γ → α} {u₂ : α → γ → β},
(∀ (b : β), GaloisConnection (Function.swap l b ∘ ⇑OrderDual.ofDual)... | null | true |
LinearIsometry.norm_map' | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂] {σ₁₂ : R →+* R₂} {E : Type u_9}
{E₂ : Type u_10} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (self : E →ₛₗᵢ[σ₁₂] E₂) (x : E), ‖self.toLinearMap x‖ = ‖x‖ | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula.0.WeierstrassCurve.Jacobian.toAffine_negAddY_of_eq._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
CategoryTheory.Limits.Concrete.isColimit_rep_eq_iff_exists | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type s}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {J : Type w}
[inst_3 : CategoryTheory.Category.{r, w} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.Limits.... | null | true |
inf_le_sup | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b : α}, a ⊓ b ≤ a ⊔ b | null | true |
exists_or_eq_left' | Init.PropLemmas | ∀ {α : Sort u_1} (y : α) (p : α → Prop), ∃ x, y = x ∨ p x | null | true |
Plausible.InjectiveFunction.shrinkPerm | Mathlib.Testing.Plausible.Functions | {α : Type} →
[DecidableEq α] →
(xs : List α) ×' (ys : List α) ×' xs.Perm ys ∧ ys.Nodup →
List ((xs : List α) ×' (ys : List α) ×' xs.Perm ys ∧ ys.Nodup) | Shrink a permutation of a list, slicing a segment in the middle.
The sizes of the slice being removed start at `n` (with `n` the length
of the list) and then `n / 2`, then `n / 4`, etc. down to 1. The slices
will be taken at index `0`, `n / k`, `2n / k`, `3n / k`, etc.
| true |
EulerProduct.eulerProduct_hasProd | Mathlib.NumberTheory.EulerProduct.Basic | ∀ {R : Type u_1} [inst : NormedCommRing R] {f : ℕ → R} [CompleteSpace R],
f 1 = 1 →
(∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) →
(Summable fun x => ‖f x‖) → f 0 = 0 → HasProd (fun p => ∑' (e : ℕ), f (↑p ^ e)) (∑' (n : ℕ), f n) | The *Euler Product* for multiplicative (on coprime arguments) functions.
If `f : ℕ → R`, where `R` is a complete normed commutative ring, `f 0 = 0`, `f 1 = 1`, `f` is
multiplicative on coprime arguments, and `‖f ·‖` is summable, then
`∏' p : Nat.Primes, ∑' e, f (p ^ e) = ∑' n, f n`. This version is stated using `HasPr... | true |
CategoryTheory.Functor.IsLocallyFaithful.of_faithful | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | ∀ {C : Type uC} [inst : CategoryTheory.Category.{vC, uC} C] {D : Type uD} [inst_1 : CategoryTheory.Category.{vD, uD} D]
{K : CategoryTheory.GrothendieckTopology D} (G : CategoryTheory.Functor C D) [G.Faithful], G.IsLocallyFaithful K | null | true |
iInf_comm | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} [inst : CompleteLattice α] {f : ι → ι' → α},
⨅ i, ⨅ j, f i j = ⨅ j, ⨅ i, f i j | null | true |
AlgebraicGeometry.instFinitaryExtensiveScheme | Mathlib.AlgebraicGeometry.Limits | CategoryTheory.FinitaryExtensive AlgebraicGeometry.Scheme | null | true |
Mathlib.Tactic.Monoidal.Context.mk.injEq | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | ∀ (level₂ level₁ : Lean.Level) (C : Q(Type level₁)) (instCat : Q(CategoryTheory.Category.{level₂, level₁} «$C»))
(instMonoidal? : Option Q(CategoryTheory.MonoidalCategory «$C»)) (level₂_1 level₁_1 : Lean.Level)
(C_1 : Q(Type level₁_1)) (instCat_1 : Q(CategoryTheory.Category.{level₂_1, level₁_1} «$C_1»))
(instMono... | null | true |
MeasureTheory.integral_restrict_infinitePi | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {mX : (i : ι) → MeasurableSpace (X i)} (μ : (i : ι) → MeasureTheory.Measure (X i))
[hμ : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] {E : Type u_3} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] {s : Finset ι} {f : ((i : ↥s) → X ↑i) → E},
MeasureTheory.AEStro... | null | true |
Set.decidableMemIoc | Mathlib.Order.Interval.Set.Basic | {α : Type u_1} →
[inst : Preorder α] → {a b x : α} → [Decidable (a < x)] → [Decidable (x ≤ b)] → Decidable (x ∈ Set.Ioc a b) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex.0.SSet.prodStdSimplex.exists_nonDegenerate_max_dim_aux._proof_1_6 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ {p q : ℕ}, p + q = p + q | null | false |
Finset.Iio_filter_lt | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_3} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrderBot α] (a b : α),
{x ∈ Finset.Iio a | x < b} = Finset.Iio (min a b) | null | true |
Bicategory.Opposite.op2 | Mathlib.CategoryTheory.Bicategory.Opposites | {B : Type u} → [inst : CategoryTheory.Bicategory B] → {a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (f.op ⟶ g.op) | Synonym for constructor of `Hom2` where the 1-morphisms `f` and `g` lie in `B` and not `Bᵒᵖ`. | true |
Real.nnabs_of_nonneg | Mathlib.Basic.NNReal.Defs | ∀ {x : ℝ}, 0 ≤ x → Real.nnabs x = x.toNNReal | null | true |
String.Slice.Pattern.ForwardPattern.rec | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{motive : String.Slice.Pattern.ForwardPattern pat → Sort u} →
((skipPrefix? : (s : String.Slice) → Option s.Pos) →
(skipPrefixOfNonempty? : (s : String.Slice) → s.isEmpty = false → Option s.Pos) →
(startsWith : String.Slice → Bool) →
motive
... | null | false |
OpenNormalAddSubgroup.instNormal | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u} [inst : AddGroup G] [inst_1 : TopologicalSpace G] (H : OpenNormalAddSubgroup G),
(↑H.toOpenAddSubgroup).Normal | null | true |
CategoryTheory.Abelian.SpectralObject.comp_hom_assoc | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.Abelian.SpectralObject C ι} (f : X.Hom Y) (g : Y.Hom Z) (n : ℤ)
{Z_1 : CategoryTheory.Functor (CategoryTheory.ComposableArrows ι... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isLongestRevMatchAt_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatch c pos =
∃ (h : s.endPos ≠ s.startPos), pos = s.endPos.prev h ∧ (s.endPos.prev h).get ⋯ = c | null | false |
LinearMap.mapMatrixModule_comp | Mathlib.LinearAlgebra.Matrix.Module | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : Ring R] [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : AddCommGroup P] [inst_8 : Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P),
... | null | true |
MonCat.Colimits.descFunLift._unsafe_rec | Mathlib.Algebra.Category.MonCat.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{u, v} J] →
(F : CategoryTheory.Functor J MonCat) → (s : CategoryTheory.Limits.Cocone F) → MonCat.Colimits.Prequotient F → ↑s.pt | null | false |
CategoryTheory.Limits.Pi.π.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (f : β → C)
[inst_1 : CategoryTheory.Limits.HasProduct f] (b : β),
CategoryTheory.Limits.Pi.π f b = CategoryTheory.Limits.limit.π (CategoryTheory.Discrete.functor f) { as := b } | null | true |
CommBialgCat.casesOn | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
{motive : CommBialgCat R → Sort u_1} →
(t : CommBialgCat R) →
((carrier : Type v) →
[commRing : CommRing carrier] →
[bialgebra : Bialgebra R carrier] →
motive { carrier := carrier, commRing := commRing, bialgebra := bialg... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.