name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.forM_eq_forM_toList._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Real.sInf_smul_of_nonpos | Mathlib.Basic.Real.Pointwise | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : Module α ℝ]
[IsOrderedModule α ℝ] {a : α}, a ≤ 0 → ∀ (s : Set ℝ), sInf (a • s) = a • sSup s | null | true |
TotalComplexShapeSymmetry.symmetry._proof_3 | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_1} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] [inst_1 : TotalComplexShape c₂ c₁ c₁₂]
[TotalComplexShapeSymmetry c₁ c₂ c₁₂] (i₂ : I₂) (i₁ : I₁), c₁.π c₂ c₁₂ (i₁, i₂) = c₂.π c₁ c₁₂ (i₂, i₁) | null | false |
Part.neg_def | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Neg α] (a : Part α), -a = Part.map (fun x => -x) a | null | true |
DiscreteConvolution.convolution.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} {S : Type u_2} {E : Type u_3} {E' : Type u_4} {F : Type u_5} [inst : Monoid M]
[inst_1 : CommSemiring S] [inst_2 : AddCommMonoid E] [inst_3 : AddCommMonoid E'] [inst_4 : AddCommMonoid F]
[inst_5 : Module S E] [inst_6 : Module S E'] [inst_7 : Module S F] [inst_8 : TopologicalSpace F]
(L : E →ₗ[S] ... | null | true |
ProbabilityTheory.Kernel.iIndepFun.indepFun_set | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8}
{m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} (S T : Set ι),
Disjoint S T →
ProbabilityTheory.Kernel.iIndepFun f ... | If `f` is a family of mutually independent random variables (`iIndepFun m f μ`) and `S, T` are
two disjoint index sets, then the tuple formed by `f i` for `i ∈ S` is independent of the
tuple `(f i)_i` for `i ∈ T`. | true |
Lean.Meta.Grind.SplitSource.forallProp.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Grind.SplitSource.forallProp e) = 1 + sizeOf e | null | true |
WithTop.instInfSet | Mathlib.Order.ConditionallyCompleteLattice.Basic | {α : Type u_1} → [LE α] → [InfSet α] → InfSet (WithTop α) | null | true |
Matroid.ground_eq_empty_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α}, M.E = ∅ ↔ M = Matroid.emptyOn α | null | true |
_private.Lean.DocString.Add.0.Lean.makeDocStringVerso.match_4 | Lean.DocString.Add | (motive : Option (String ⊕ Lean.VersoDocString) → Sort u_1) →
(__x : Option (String ⊕ Lean.VersoDocString)) →
((doc : String ⊕ Lean.VersoDocString) → motive (some doc)) →
((x : Option (String ⊕ Lean.VersoDocString)) → motive x) → motive __x | null | false |
Lean.Meta.Grind.Arith.Linear.MonadGetStruct.mk | Lean.Meta.Tactic.Grind.Arith.Linear.LinearM | {m : Type → Type} → m Lean.Meta.Grind.Arith.Linear.Struct → Lean.Meta.Grind.Arith.Linear.MonadGetStruct m | null | true |
Nat.Prime.primeFactors | Mathlib.Data.Nat.PrimeFin | ∀ {p : ℕ}, Nat.Prime p → p.primeFactors = {p} | null | true |
Real.log._proof_1 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ (x : ℝ), ¬x = 0 → 0 < |x| | null | false |
AlgebraicGeometry.IsSeparated.comp_iff | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {g : Y ⟶ Z} [AlgebraicGeometry.IsSeparated g],
AlgebraicGeometry.IsSeparated (CategoryTheory.CategoryStruct.comp f g) ↔ AlgebraicGeometry.IsSeparated f | null | true |
AddOpposite.instDivisionRing._proof_6 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [DivisionRing α], Nontrivial αᵃᵒᵖ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.PosLog.0.circleAverage_log_norm_sub_const_eq_log_radius_add_posLog._simp_1_5 | Mathlib.Analysis.SpecialFunctions.Integrals.PosLog | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.FreeMonoidalCategory.HomEquiv.pentagon | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {W X Y Z : CategoryTheory.FreeMonoidalCategory C},
CategoryTheory.FreeMonoidalCategory.HomEquiv
(((CategoryTheory.FreeMonoidalCategory.Hom.α_hom W X Y).whiskerRight Z).comp
((CategoryTheory.FreeMonoidalCategory.Hom.α_hom W (X.tensor Y) Z).comp
(CategoryTheory.FreeMonoidalCategory.Hom.... | null | true |
Std.DTreeMap.Internal.Impl.getD_insertMany!_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} {fallback : β k'},
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq)... | null | true |
IsAddUnit.of_nsmul_eq_zero | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] {n : ℕ} {a : M}, n • a = 0 → n ≠ 0 → IsAddUnit a | null | true |
CategoryTheory.MorphismProperty.instRespectsIsoArrowArrow | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] (W : CategoryTheory.MorphismProperty C) [W.RespectsIso],
W.arrow.RespectsIso | null | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Zero.trySend' | Std.Sync.Channel | {α : Type} → α → Std.AtomicT (Std.CloseableChannel.Zero.State✝ α) BaseIO Bool | Precondition: The channel must not be closed.
| true |
ContinuousLinearMap.setIntegral_compLp | Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap | ∀ {X : Type u_1} {E : Type u_3} {F : Type u_4} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} {𝕜 : Type u_6}
{𝕜' : Type u_7} [inst_1 : RCLike 𝕜] [inst_2 : RCLike 𝕜'] [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜' F] {p : ENNReal} [... | null | true |
Valuation.instFunLike | Mathlib.RingTheory.Valuation.Basic | {R : Type u_3} →
{Γ₀ : Type u_4} → [inst : Ring R] → [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] → FunLike (Valuation R Γ₀) R Γ₀ | null | true |
RingQuot.definition._@.Mathlib.Algebra.RingQuot.3469094938._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Semiring R] → (r : R → R → Prop) → R →+* RingQuot r | null | false |
Prefunctor.costar_snd | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V) (u : U) (a : Quiver.Costar u),
(φ.costar u a).snd = φ.map a.snd | null | true |
Algebra.Presentation.relation_mem_ker | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Presentation R S ι σ) (i : σ), P.relation i ∈ P.ker | null | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_284 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
_private.Mathlib.Tactic.Ring.Compare.0.Mathlib.Tactic.Ring.proveLE.match_1 | Mathlib.Tactic.Ring.Compare | (motive : Lean.Expr → Sort u_1) →
(__x : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → ((x : Lean.Expr) → motive x) → motive __x | null | false |
groupHomology.cycles₁_eq_top_of_isTrivial | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) [A.IsTrivial],
groupHomology.cycles₁ A = ⊤ | null | true |
MeasureTheory.OuterMeasure.coe_iSup | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} {ι : Sort u_3} (f : ι → MeasureTheory.OuterMeasure α), ⇑(⨆ i, f i) = ⨆ i, ⇑(f i) | null | true |
Equiv.mul_swap_eq_iff | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} [inst : DecidableEq α] {i j : α} {σ : Equiv.Perm α}, σ * Equiv.swap i j = σ ↔ i = j | null | true |
LinOrd.Iso.mk_hom | Mathlib.Order.Category.LinOrd | ∀ {α β : LinOrd} (e : ↑α ≃o ↑β), (LinOrd.Iso.mk e).hom = LinOrd.ofHom ↑e | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Quaternion.0.instDecidableEqQuaternionGroup.decEq.match_1.splitter | Mathlib.GroupTheory.SpecificGroups.Quaternion | {n : ℕ} →
(motive : QuaternionGroup n → QuaternionGroup n → Sort u_1) →
(x x_1 : QuaternionGroup n) →
((a b : ZMod (2 * n)) → motive (QuaternionGroup.a a) (QuaternionGroup.a b)) →
((a a_1 : ZMod (2 * n)) → motive (QuaternionGroup.a a) (QuaternionGroup.xa a_1)) →
((a a_1 : ZMod (2 * n)) → m... | null | true |
DFinsupp.mapRange_injective | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [inst : (i : ι) → Zero (β₁ i)] [inst_1 : (i : ι) → Zero (β₂ i)]
(f : (i : ι) → β₁ i → β₂ i) (hf : ∀ (i : ι), f i 0 = 0),
Function.Injective (DFinsupp.mapRange f hf) ↔ ∀ (i : ι), Function.Injective (f i) | null | true |
NumberField.mixedEmbedding.fundamentalCone.expMap_single._proof_5 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] (w : NumberField.InfinitePlace K),
ContinuousOn (fun y => Real.exp (((fun x => (↑w.mult)⁻¹) * id) y)) Set.univ | null | false |
_private.Mathlib.Analysis.Convolution.0.MeasureTheory.support_convolution_subset_swap._simp_1_3 | Mathlib.Analysis.Convolution | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
RingEquiv.coe_toRingHom | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R ≃+* S), ⇑↑f = ⇑f | null | true |
_private.Std.WP.Triple.SpecLemmas.0.List.forIn'_cons.match_1.splitter | Std.WP.Triple.SpecLemmas | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(x : ForInStep β) → ((b : β) → motive (ForInStep.done b)) → ((b : β) → motive (ForInStep.yield b)) → motive x | null | true |
_private.Mathlib.Data.Set.SymmDiff.0.Set.symmDiff_union_subset._proof_1_1 | Mathlib.Data.Set.SymmDiff | ∀ {α : Type u_1} {s t u : Set α}, symmDiff s (t ∪ u) ⊆ symmDiff s t ∪ symmDiff s u | null | false |
CategoryTheory.ShortComplex.Homotopy.unop._proof_5 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex Cᵒᵖ} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
(CategoryTheory.ShortComplex.unopMap φ₁).τ₁ =
CategoryTheory.CategoryStruct.comp S₂.unop.f h.h₂.uno... | null | false |
TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace.ctorIdx | Mathlib.Topology.Metrizable.CompletelyMetrizable | {X : Type u_3} → TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace X → ℕ | null | false |
CompletePartialOrder.ofLubOfDirected | Mathlib.Order.CompletePartialOrder | (α : Type u_4) →
[H1 : PartialOrder α] →
[H2 : SupSet α] → (∀ (d : Set α), DirectedOn (fun x1 x2 => x1 ≤ x2) d → IsLUB d (sSup d)) → CompletePartialOrder α | Create a `CompletePartialOrder` from a `PartialOrder` and `SupSet`
such that for every directed set `d`, `sSup d` is the least upper bound of `d`.
The bottom element is defined as `sSup ∅`.
| true |
Rat.toNNRat_div | Mathlib.Data.NNRat.Lemmas | ∀ {p q : ℚ}, 0 ≤ p → (p / q).toNNRat = p.toNNRat / q.toNNRat | null | true |
Std.Http.Internal.ChunkedBuffer.recOn | Std.Http.Internal.ChunkedBuffer | {motive : Std.Http.Internal.ChunkedBuffer → Sort u} →
(t : Std.Http.Internal.ChunkedBuffer) →
((data : Array ByteArray) → (size : ℕ) → motive { data := data, size := size }) → motive t | null | false |
Lean.Lsp.ResolvableCompletionList.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | Bool → Array Lean.Lsp.ResolvableCompletionItem → Lean.Lsp.ResolvableCompletionList | null | false |
RingCon.kerLiftₐ_injective | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} {R : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring M] [inst_2 : Algebra R M]
[inst_3 : Semiring P] [inst_4 : Algebra R P] (f : M →ₐ[R] P), Function.Injective ⇑(RingCon.kerLiftₐ f) | A ring homomorphism `f` induces an injective homomorphism on the quotient by `f`'s kernel. | true |
differentiableAt_comp_add_right | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} (a : E), DifferentiableAt 𝕜 (fun x => f (x + a)) x ↔ DifferentiableAt 𝕜 f (x + a) | null | true |
Qq._aux_Qq_Macro___unexpand_Qq_QuotedDefEq_1 | Qq.Macro | Lean.PrettyPrinter.Unexpander | null | false |
DirectSum.instCommSemiringOfNat._proof_5 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommSemiring A] (a b : A 0),
(DirectSum.of A 0) (a * b) = (DirectSum.of A 0) a * (DirectSum.of A 0) b | null | false |
Std.IterM.forM_eq_forIn | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] {n : Type w → Type w''}
[inst_2 : Monad m] [inst_3 : Monad n] [LawfulMonad n] [inst_5 : Std.IteratorLoop α m n] [Std.LawfulIteratorLoop α m n]
[inst_7 : MonadLiftT m n] {it : Std.IterM m β} {f : β → n PUnit.{w + 1}},
fo... | null | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.compileStxMatch._sparseCasesOn_7 | Lean.Elab.Quotation | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.Meta.Grind.ENode.ematchDiagSource | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENode → Lean.Meta.Grind.EMatchDiagSource | Auxiliary field used to implement `grind.ematch.diagnostics` | true |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.fullyFaithulι | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
{D : Type u₃} →
{inst_4 : CategoryTheory.Cat... | **Alias** of `CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.fullyFaithfulι`.
---
The functor `ι` is fully faithful. | true |
Std.PRange.UpwardEnumerable.succ?_inj | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α] {a b : α},
Std.PRange.succ? a = Std.PRange.succ? b ↔ a = b | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.EncodedQueryString.decode._proof_1 | Std.Http.Data.URI.Encoding | ∀ {r : UInt8 → Bool} (es : Std.Http.URI.EncodedQueryString r) (__s : ByteArray × ℕ) (h : __s.2 < es.toByteArray.size),
(es.toByteArray[__s.2] == '%'.toNat.toUInt8) = true ∧ __s.2 + 1 < es.toByteArray.size →
¬__s.2 + 1 < es.toByteArray.size → False | null | false |
Subgroup.instCompleteLattice.eq_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G],
Subgroup.instCompleteLattice =
{ toSemilatticeSup := (completeLatticeOfInf (Subgroup G) ⋯).toSemilatticeSup, inf := fun x1 x2 => x1 ⊓ x2,
inf_le_left := ⋯, inf_le_right := ⋯, le_inf := ⋯, toSupSet := (completeLatticeOfInf (Subgroup G) ⋯).toSupSet,
isLUB_sSup := ⋯, to... | null | true |
Matrix.conjTranspose_zero | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : AddMonoid α] [inst_1 : StarAddMonoid α], Matrix.conjTranspose 0 = 0 | null | true |
Homeomorph.toOpenPartialHomeomorph_apply | Mathlib.Topology.OpenPartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y),
↑e.toOpenPartialHomeomorph = ⇑e | null | true |
IsMinOn.min | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] {f g : α → β} {a : α} {s : Set α},
IsMinOn f s a → IsMinOn g s a → IsMinOn (fun x => min (f x) (g x)) s a | null | true |
CategoryTheory.Join.mkNatTransComp._auto_1 | Mathlib.CategoryTheory.Join.Basic | Lean.Syntax | null | false |
Real.deriv_rpow_const | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ (x p : ℝ), deriv (fun x => x ^ p) x = p * x ^ (p - 1) | null | true |
Ideal.cotangentIdeal_square | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u} [inst : CommRing R] (I : Ideal R), I.cotangentIdeal ^ 2 = ⊥ | null | true |
String.copy_sliceFrom_eq_iff_exists_splits | Init.Data.String.Lemmas.Splits | ∀ {s : String} {p : s.Pos} {t₂ : String}, (s.sliceFrom p).copy = t₂ ↔ ∃ t₁, p.Splits t₁ t₂ | null | true |
CategoryTheory.Limits.prod.braiding_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : C) [inst_1 : CategoryTheory.Limits.HasBinaryProduct P Q]
[inst_2 : CategoryTheory.Limits.HasBinaryProduct Q P],
(CategoryTheory.Limits.prod.braiding P Q).inv =
CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.pro... | null | true |
Subtype.coe_inf._simp_1 | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {P : α → Prop} (Pinf : ∀ ⦃x y : α⦄, P x → P y → P (x ⊓ y)) (x y : Subtype P),
↑x ⊓ ↑y = ↑(x ⊓ y) | null | false |
Std.Iter.toArray_flatMap | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α α₂ β γ : Type w} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterator α₂ Id γ] [Std.Iterators.Finite α Id]
[Std.Iterators.Finite α₂ Id] [inst : Std.Iterator α Id β] [inst_2 : Std.Iterator α₂ Id γ] [Std.Iterators.Finite α Id]
[Std.Iterators.Finite α₂ Id] {f : β → Std.Iter γ} {it₁ : Std.Iter β},
(Std.Iter.flatM... | null | true |
HomotopicalAlgebra.Cylinder.IsGood.cofibration_i | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {A : C}
{inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C} {P : HomotopicalAlgebra.Cylinder A}
{inst_2 : CategoryTheory.Limits.HasBinaryCoproduct A A} {inst_3 : HomotopicalAlgebra.CategoryWithCofibrations C}
[self : P.IsGood], HomotopicalAlgebra.C... | null | true |
Turing.TM2ComputableInPolyTime.mk.inj | Mathlib.Computability.TuringMachine.Computable | ∀ {α β αΓ βΓ : Type} {ea : α → List αΓ} {eb : β → List βΓ} {f : α → β}
{toTM2ComputableAux : Turing.TM2ComputableAux αΓ βΓ} {time : Polynomial ℕ}
{outputsFun :
(a : α) →
Turing.TM2OutputsInTime toTM2ComputableAux.tm (List.map toTM2ComputableAux.inputAlphabet.invFun (ea a))
(some (List.map toTM2Com... | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.InductionObj.powBound | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | {R : Type u_2} → [inst : CommRing R] → {n : ℕ} → ChevalleyThm.PolynomialC.InductionObj✝ R n → ℕ | The bound on the power of the subgroup generated by the coefficients of the polynomials used to
describe the constructible set appearing in the case of `C : R → R[X]` of Chevalley's theorem with
complexity bound. | true |
Set.Icc.semilatticeSup._proof_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a b : α} [inst : SemilatticeSup α] (x y : α), x ∈ Set.Icc b a → y ∈ Set.Icc b a → x ⊔ y ∈ Set.Icc b a | null | false |
CategoryTheory.eqToIso._proof_1 | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (p : X = Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) (CategoryTheory.eqToHom ⋯) =
CategoryTheory.CategoryStruct.id X | null | false |
ArchimedeanClass.instCommRingFiniteElement | Mathlib.Algebra.Order.Ring.StandardPart | (K : Type u_1) →
[inst : LinearOrder K] → [inst_1 : Field K] → [inst_2 : IsOrderedRing K] → CommRing (ArchimedeanClass.FiniteElement K) | null | true |
GradedLieAlgebra | Mathlib.Algebra.Lie.Graded | {ι : Type u_1} →
{R : Type u_5} →
{L : Type u_6} →
[DecidableEq ι] →
[AddCommMonoid ι] →
[inst : CommRing R] →
[inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → (ι → Submodule R L) → Type (max u_1 u_6) | A class that ensures a Lie algebra has a bracket that preserves a decomposition. | true |
Aesop.Frontend.declareRuleSetUnchecked | Aesop.Frontend.Extension | Aesop.RuleSetName → Bool → IO Unit | null | true |
Matrix.permanent_zero | Mathlib.LinearAlgebra.Matrix.Permanent | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_2} [inst_2 : CommSemiring R] [Nonempty n],
Matrix.permanent 0 = 0 | null | true |
Irrational.ratCast_sub | Mathlib.NumberTheory.Real.Irrational | ∀ (q : ℚ) {x : ℝ}, Irrational x → Irrational (↑q - x) | null | true |
schnirelmannDensity_lt_iff | Mathlib.Combinatorics.Schnirelmann | ∀ {A : Set ℕ} [inst : DecidablePred fun x => x ∈ A] {x : ℝ},
schnirelmannDensity A < x ↔ ∃ n, 0 < n ∧ ↑{a ∈ Finset.Ioc 0 n | a ∈ A}.card / ↑n < x | null | true |
GroupSeminormClass.toNonnegHomClass | Mathlib.Algebra.Order.Hom.GroupNorm | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Group α] [inst_2 : AddCommMonoid β]
[inst_3 : LinearOrder β] [IsOrderedAddMonoid β] [GroupSeminormClass F α β], NonnegHomClass F α β | null | true |
Torsor.mk.noConfusion | Mathlib.Algebra.Torsor.Defs | {G : outParam (Type u_1)} →
{P : Type u_2} →
{inst : Group G} →
{P_1 : Sort u} →
{toMulAction : MulAction G P} →
{toSDiv : SDiv G P} →
{nonempty : Nonempty P} →
{sdiv_smul' : ∀ (p₁ p₂ : P), (p₁ /ₛ p₂) • p₂ = p₁} →
{smul_sdiv' : ∀ (g : G) (p : P), g... | null | false |
SSet.stdSimplex.faceRepresentableBy._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory}
(x : (SSet.stdSimplex.obj { len := n }).obj (Opposite.op j)) (hx : x ∈ (SSet.stdSimplex.face S).obj (Opposite.op j))
(i₁ i₂ : Fin (j.len + 1)),
i₁ ≤ i₂ →
e.symm ⟨(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv... | null | false |
Std.DTreeMap.get?_insertMany_list_of_mem._proof_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_2} {β : α → Type u_1} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp] {k k' : α},
cmp k k' = Ordering.eq → β k = β k' | null | false |
_private.Lean.Meta.DiscrTree.Basic.0.Lean.Meta.DiscrTree.insertVal.loop | Lean.Meta.DiscrTree.Basic | {α : Type u_1} → [BEq α] → Array α → α → ℕ → Array α | null | true |
Batteries.BinaryHeap.mk.noConfusion | Batteries.Data.BinaryHeap.Basic | {α : Type w} →
{inst : Ord α} → {P : Sort u} → {arr arr' : Array α} → { arr := arr } = { arr := arr' } → (arr ≍ arr' → P) → P | null | false |
ContinuousAddEquiv.coe_refl | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ (M : Type u_1) [inst : TopologicalSpace M] [inst_1 : Add M], ⇑(ContinuousAddEquiv.refl M) = id | null | true |
Lean.Compiler.LCNF.LitValue.nat.sizeOf_spec | Lean.Compiler.LCNF.Basic | ∀ (val : ℕ), sizeOf (Lean.Compiler.LCNF.LitValue.nat val) = 1 + sizeOf val | null | true |
PFunctor.Approx.approx_eta | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {n : ℕ} (x : PFunctor.Approx.CofixA F (n + 1)),
x = PFunctor.Approx.CofixA.intro (PFunctor.Approx.head' x) (PFunctor.Approx.children' x) | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.hasIndependentPatterns.match_1 | Lean.Meta.Match.Match | (motive : Lean.Meta.Match.Pattern → Sort u_1) →
(p : Lean.Meta.Match.Pattern) →
((e : Lean.Expr) → motive (Lean.Meta.Match.Pattern.inaccessible e)) →
((fvarId : Lean.FVarId) → motive (Lean.Meta.Match.Pattern.var fvarId)) →
((varId : Lean.FVarId) →
(p : Lean.Meta.Match.Pattern) → (hId : L... | null | false |
_private.Mathlib.Tactic.Push.Attr.0.Mathlib.Tactic.Push.isPullThm._sparseCasesOn_1 | Mathlib.Tactic.Push.Attr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Algebra.Presentation.coeffs_relation_subset_core | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ} (x : σ), ↑(MvPolynomial.coeffs (P.relation x)) ⊆ ↑P.core | null | true |
Std.Format.MonadPrettyFormat.mk.noConfusion | Init.Data.Format.Basic | {m : Type → Type} →
{P : Sort u} →
{pushOutput : String → m Unit} →
{pushNewline : ℕ → m Unit} →
{currColumn : m ℕ} →
{startTag endTags : ℕ → m Unit} →
{pushOutput' : String → m Unit} →
{pushNewline' : ℕ → m Unit} →
{currColumn' : m ℕ} →
... | null | false |
Lean.Lsp.TextDocumentSyncOptions.mk._flat_ctor | Lean.Data.Lsp.TextSync | Bool → Lean.Lsp.TextDocumentSyncKind → Bool → Bool → Option Lean.Lsp.SaveOptions → Lean.Lsp.TextDocumentSyncOptions | null | false |
Real.rpow_le_of_le_log | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y z : ℝ}, 0 < y → Real.log x ≤ z * Real.log y → x ≤ y ^ z | null | true |
TensorProduct.mapOfCompatibleSMul_tmul | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_13) (S : Type u_14) (M : Type u_15) (N : Type u_16)
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N]
[inst_5 : CommSemiring A] [inst_6 : Module A M] [inst_7 : Module A N] [inst_8 : SMulCommClass R A M]
[inst_9 : ... | null | true |
Subring.mem_unop | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R] {x : R} {S : Subring Rᵐᵒᵖ}, x ∈ S.unop ↔ MulOpposite.op x ∈ S | null | true |
_private.LeanSearchClient.LoogleSyntax.0.LeanSearchClient.getLoogleQueryJson.match_6 | LeanSearchClient.LoogleSyntax | (motive : Except String String → Sort u_1) →
(error? : Except String String) →
((error : String) → motive (Except.ok error)) → ((x : Except String String) → motive x) → motive error? | null | false |
CategoryTheory.Oplax.LaxTrans.vCompNaturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H : CategoryTheory.OplaxFunctor B C} →
(η : CategoryTheory.Oplax.LaxTrans F G) →
(θ : CategoryTheory.Oplax.LaxTrans G H) →
{a b : B} →
... | Auxiliary definition for `vComp`. | true |
Int.default_eq_zero | Init.Data.Int.Basic | default = 0 | null | true |
_private.Aesop.Forward.State.0.Aesop.InstMap.modify._sparseCasesOn_7 | Aesop.Forward.State | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.WithInitial.liftFromUnderComp._proof_5 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {J : Type u_1} [inst_2 : CategoryTheory.Category.{u_2, u_1} J] {X : C}
{K : CategoryTheory.Functor J (CategoryTheory.Under X)} {F : CategoryTheory.Functor C D}
⦃X_1 Y : CategoryTheory.With... | null | false |
Except.pmap._proof_1 | Batteries.Data.Except | ∀ {ε : Type u_1} {α : Type u_2} (a : α), Except.ok a = Except.ok a | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.