name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Linter.MissingDocs.checkSyntaxAbbrev | Lean.Linter.MissingDocs | Lean.Linter.MissingDocs.SimpleHandler | null | true |
OrderHom.apply_mono | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {f g : α →o β} {x y : α},
f ≤ g → x ≤ y → f x ≤ g y | null | true |
Finset.image₂_right_comm | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {δ : Type u_7} {δ' : Type u_8} {ε : Type u_9} [inst : DecidableEq δ']
[inst_1 : DecidableEq ε] {s : Finset α} {t : Finset β} [inst_2 : DecidableEq δ] {γ : Type u_14} {u : Finset γ}
{f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε},
(∀ (a : α) (b : β) (c : γ), f (g... | null | true |
minpoly.coeff_zero_eq_zero._simp_1 | Mathlib.FieldTheory.Minpoly.Field | ∀ {A : Type u_1} {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [IsDomain B] [inst_3 : Algebra A B] {x : B},
IsIntegral A x → ((minpoly A x).coeff 0 = 0) = (x = 0) | null | false |
Lean.Kernel.Exception.casesOn | Lean.Environment | {motive : Lean.Kernel.Exception → Sort u} →
(t : Lean.Kernel.Exception) →
((env : Lean.Kernel.Environment) → (name : Lean.Name) → motive (Lean.Kernel.Exception.unknownConstant env name)) →
((env : Lean.Kernel.Environment) → (name : Lean.Name) → motive (Lean.Kernel.Exception.alreadyDeclared env name)) →
... | null | false |
exteriorPower.oneEquiv._proof_4 | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ (M : Type u_1) [inst : AddCommGroup M] (m : M), (fun x => m) = Function.update (fun x => 0) 0 m | null | false |
Lean.NameSSet.insert | Lean.Data.NameMap.Basic | Lean.NameSSet → Lean.Name → Lean.NameSSet | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.LeviCivita.0.CovariantDerivative.leviCivitaAuxOfMDiffAt._proof_5 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.LeviCivita | ContinuousConstSMul ℝ ℝ | null | false |
Lean.Lsp.RpcReleaseParams.ctorIdx | Lean.Data.Lsp.Extra | Lean.Lsp.RpcReleaseParams → ℕ | null | false |
MeasurableEquiv.ext | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {e₁ e₂ : α ≃ᵐ β},
⇑e₁ = ⇑e₂ → e₁ = e₂ | null | true |
FirstOrder.Language.isEmpty_functions_constantsOn_succ | Mathlib.ModelTheory.LanguageMap | ∀ {α : Type u'} {n : ℕ}, IsEmpty ((FirstOrder.Language.constantsOn α).Functions (n + 1)) | null | true |
Circle.mem_centeredArc_div | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {z : Circle} {s : ℝ} {n : ℕ},
s ≤ Real.pi → z ∈ Circle.centeredArc (Real.pi / ↑n) → z ^ n ∈ Circle.centeredArc s → z ∈ Circle.centeredArc (s / ↑n) | null | true |
CompTriple.instComp_id | Mathlib.Logic.Function.CompTypeclasses | ∀ {N : Type u_1} {P : Type u_2} {φ : N → N} [CompTriple.IsId φ] {ψ : N → P}, CompTriple φ ψ ψ | null | true |
CategoryTheory.Pseudofunctor.mapComp'₀₁₃_hom_comp_whiskerLeft_mapComp'_hom_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.Pseudofunctor B C) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁)
(f₁₂ : b₁ ⟶ b₂) (f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃)
(h₀₂ : Cate... | null | true |
Algebra.coe_linearMap | Mathlib.Algebra.Algebra.Defs | ∀ (R : Type u) (A : Type w) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
⇑(Algebra.linearMap R A) = ⇑(algebraMap R A) | null | true |
CategoryTheory.Limits.zero_of_source_iso_zero | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : Y ⟶ X) (i : Y ≅ 0), f = 0 | null | true |
Std.HashSet.diff | Std.Data.HashSet.Basic | {α : Type u} → [inst : BEq α] → [inst_1 : Hashable α] → Std.HashSet α → Std.HashSet α → Std.HashSet α | Computes the difference of the given hash sets.
This function always iterates through the smaller set, so the expected runtime is
`O(min(m₁.size, m₂.size))`.
| true |
CategoryTheory.Functor.toEventualRanges_finite | Mathlib.CategoryTheory.CofilteredSystem | ∀ {J : Type u} [inst : CategoryTheory.Category.{v_1, u} J] (F : CategoryTheory.Functor J (Type v))
[inst_1 : CategoryTheory.IsCofilteredOrEmpty J] [∀ (j : J), Finite (F.obj j)] (j : J),
Finite (F.toEventualRanges.obj j) | null | true |
Mathlib.Tactic.Linarith.sub_nonpos_of_le | Mathlib.Tactic.Linarith.Lemmas | ∀ {α : Type u} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] {a b : α}, a ≤ b → a - b ≤ 0 | null | true |
FirstOrder.Language.Substructure.inclusion.congr_simp | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S T : L.Substructure M} (h : S ≤ T),
FirstOrder.Language.Substructure.inclusion h = FirstOrder.Language.Substructure.inclusion h | null | true |
QuadraticForm.equivalent_one_zero_neg_one_weighted_sum_squared | Mathlib.LinearAlgebra.QuadraticForm.Real | ∀ {M : Type u_2} [inst : AddCommGroup M] [inst_1 : Module ℝ M] [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M),
∃ w,
(∀ (i : Fin (Module.finrank ℝ M)), w i = -1 ∨ w i = 0 ∨ w i = 1) ∧
QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares ℝ w) | **Sylvester's law of inertia**: A real quadratic form is equivalent to a weighted
sum of squares with the weights being ±1 or 0. | true |
AlgebraicGeometry.ΓSpec.locallyRingedSpaceAdjunction_homEquiv_apply | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ {X : AlgebraicGeometry.LocallyRingedSpace} {R : CommRingCatᵒᵖ}
(f : AlgebraicGeometry.LocallyRingedSpace.Γ.rightOp.obj X ⟶ R),
(AlgebraicGeometry.ΓSpec.locallyRingedSpaceAdjunction.homEquiv X R) f =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.identityToΓSpec.app X)
(AlgebraicGeometry.Spec.loca... | null | true |
LinearMap.convNonUnitalSemiring | Mathlib.RingTheory.Coalgebra.Convolution | {R : Type u_1} →
{A : Type u_3} →
{C : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : AddCommMonoid C] →
[inst_6 : Module R ... | Non-unital convolution semiring structure on linear maps from a coalgebra to a
non-unital algebra. | true |
CategoryTheory.locallyDiscreteBicategory | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | (C : Type u) → [CategoryTheory.Category.{v, u} C] → CategoryTheory.Bicategory (CategoryTheory.LocallyDiscrete C) | The locally discrete bicategory on a category is a bicategory in which the objects and the
1-morphisms are the same as those in the underlying category, and the 2-morphisms are the
equalities between 1-morphisms.
| true |
PolynomialLaw.toFun_eq_rTensor_φ_toFun' | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {S : Type v} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
(f : M →ₚₗ[R] N) {t : TensorProduct R S M} {s : Finset S} {p : TensorProduct R (MvPolyn... | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.Code.instantiateValueLevelParams.instAlt | Lean.Compiler.LCNF.Basic | List Lean.Name →
List Lean.Level →
Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure | null | true |
Batteries.BinaryHeap.heapifyDown._unary.induct | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} {sz : ℕ} [inst : Ord α] (motive : (_ : Vector α sz) ×' Fin sz → Prop),
(∀ (a : Vector α sz) (i : Fin sz), Batteries.BinaryHeap.maxChild a i = none → motive ⟨a, i⟩) →
(∀ (a : Vector α sz) (i j : Fin sz),
Batteries.BinaryHeap.maxChild a i = some j →
i < j → (compare a[i] a[j]).isL... | null | false |
CategoryTheory.Sum.functorEquiv._proof_2 | Mathlib.CategoryTheory.Sums.Products | ∀ (A : Type u_5) [inst : CategoryTheory.Category.{u_1, u_5} A] (A' : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} A'] (B : Type u_6) [inst_2 : CategoryTheory.Category.{u_3, u_6} B]
{X Y Z : CategoryTheory.Functor (A ⊕ A') B} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Prod.mkHom ((CategoryTheory.Sum.inl_ A ... | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_31 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (cond ifTrue ifFalse : Std.Sat.AIG.Fanin),
ifTrue.gate < upper → ∀ (fstate : Std.Sat.AIG.toCNF.State✝ aig), ifTrue.gate < aig.decls.size | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.keys_map._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
MeasurableEquiv.sumProdSum | Mathlib.MeasureTheory.MeasurableSpace.Embedding | (α : Type u_6) →
(β : Type u_7) →
(γ : Type u_8) →
(δ : Type u_9) →
[inst : MeasurableSpace α] →
[inst_1 : MeasurableSpace β] →
[inst_2 : MeasurableSpace γ] →
[inst_3 : MeasurableSpace δ] → (α ⊕ β) × (γ ⊕ δ) ≃ᵐ (α × γ ⊕ α × δ) ⊕ β × γ ⊕ β × δ | Products distribute over sums as measurable spaces. | true |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory.0.CategoryTheory.Triangulated.AbelianSubcategory.eq_zero_of_hom_shift_pos._proof_1_1 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {n : ℤ}, 0 < n → -n < 0 | null | false |
TrivSqZeroExt.algebraMap_eq_inlHom | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ (R' : Type u) (M : Type v) [inst : CommSemiring R'] [inst_1 : AddCommMonoid M] [inst_2 : Module R' M]
[inst_3 : Module R'ᵐᵒᵖ M] [inst_4 : IsCentralScalar R' M],
algebraMap R' (TrivSqZeroExt R' M) = TrivSqZeroExt.inlHom R' M | null | true |
Lean.ParametricAttributeImpl._sizeOf_1 | Lean.Attributes | {α : Type} → [SizeOf α] → Lean.ParametricAttributeImpl α → ℕ | null | false |
PrimeSpectrum.nonempty_iff_nontrivial | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u} [inst : CommSemiring R], Nonempty (PrimeSpectrum R) ↔ Nontrivial R | null | true |
MulAction.stabilizer._proof_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ (G : Type u_2) {α : Type u_1} [inst : Group G] [inst_1 : MulAction G α] (a : α) {m : G}, m • a = a → m⁻¹ • a = a | null | false |
ContMDiffMap.commRing._proof_4 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E' : Type u_3} [inst_1 : NormedAddCommGroup E']
[inst_2 : NormedSpace 𝕜 E'] {H' : Type u_2} [inst_3 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{n : WithTop ℕ∞} {R : Type u_4} [inst_4 : CommRing R] [inst_5 : TopologicalSpace R] [inst_6 : ChartedSpa... | null | false |
eventually_homothety_image_subset_of_finite_subset_interior | Mathlib.Topology.Algebra.Affine | ∀ (R : Type u_1) {W : Type u_4} {Q : Type u_5} [inst : AddCommGroup W] [inst_1 : TopologicalSpace W]
[inst_2 : AddTorsor W Q] [inst_3 : TopologicalSpace Q] [IsTopologicalAddTorsor Q] [inst_5 : CommRing R]
[inst_6 : TopologicalSpace R] [inst_7 : Module R W] [ContinuousSMul R W] (x : Q) {s t : Set Q},
t.Finite → t ... | null | true |
_private.Mathlib.FieldTheory.SeparableDegree.0.Polynomial.natSepDegree_mul_eq_iff._simp_1_6 | Mathlib.FieldTheory.SeparableDegree | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = ∀ a ∈ s, ∀ b ∈ t, a ≠ b | null | false |
Cardinal.IsRegular.of_not_isSingular | Mathlib.SetTheory.Cardinal.Regular | ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → ¬c.IsSingular → c.IsRegular | null | true |
Std.Internal.List.isEmpty_eq_false_iff_exists_isSome_getEntry? | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [ReflBEq α] {l : List ((a : α) × β a)},
l.isEmpty = false ↔ ∃ a, (Std.Internal.List.getEntry? a l).isSome = true | null | true |
CategoryTheory.Precoverage.Generates.casesOn | Mathlib.CategoryTheory.Sites.Precoverage.Generates | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{K : CategoryTheory.Precoverage C} →
{J : CategoryTheory.GrothendieckTopology C} →
{motive : K.Generates J → Sort u_1} →
(t : K.Generates J) →
((le_toPrecoverage : K ≤ J.toPrecoverage) →
(isSheaf_of_fora... | null | false |
CategoryTheory.Comonad.cofree_obj_A | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (G : CategoryTheory.Comonad C) (X : C),
(G.cofree.obj X).A = G.obj X | null | true |
LinearMap.BilinForm.IsNonneg.nonneg | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : LE R]
{B : LinearMap.BilinForm R M}, B.IsNonneg → ∀ (x : M), 0 ≤ (B x) x | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.sign_two_nsmul_eq_sign_iff._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, (θ.sin = 0) = (θ = 0 ∨ θ = ↑Real.pi) | null | false |
Lean.KVMap.instValueString._sparseCasesOn_1 | Lean.Data.KVMap | {motive : Lean.DataValue → Sort u} →
(t : Lean.DataValue) →
((v : String) → motive (Lean.DataValue.ofString v)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
PowerSeries.substAlgHom_comp_substAlgHom_apply | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] {S : Type u_4} [inst_1 : CommRing S] {υ : Type u_5} {T : Type u_6}
[inst_2 : CommRing T] [inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] {a : PowerSeries S}
{b : MvPowerSeries υ T} [IsScalarTower R S T] (ha : PowerSeries.HasSubst a) (hb : PowerSeries.HasSubs... | null | true |
Lean.Grind.NoopConfig.mk | Init.Grind.Config | Lean.Grind.Config → Lean.Grind.NoopConfig | null | true |
Submodule.mem_ideal_smul_span_iff_exists_sum | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (I : Ideal R)
[I.IsTwoSided] {ι : Type u_4} (f : ι → M) (x : M),
x ∈ I • Submodule.span R (Set.range f) ↔ ∃ a, ∃ (_ : ∀ (i : ι), a i ∈ I), (a.sum fun i c => c • f i) = x | If `x` is an `I`-multiple of the submodule spanned by `f '' s`,
then we can write `x` as an `I`-linear combination of the elements of `f '' s`. | true |
SSet.Nonsingular.recOn | Mathlib.AlgebraicTopology.SimplicialSet.Nonsingular | {X : SSet} →
{motive : X.Nonsingular → Sort u_1} →
(t : X.Nonsingular) →
((mono : ∀ {n : ℕ} (x : ↑(X.nonDegenerate n)), CategoryTheory.Mono (SSet.yonedaEquiv.symm ↑x)) → motive ⋯) →
motive t | null | false |
IntermediateField.finInsepDegree_top | Mathlib.FieldTheory.SeparableClosure | ∀ {F : Type u} (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [inst_6 : IsScalarTower F E K],
Field.finInsepDegree F ↥⊤ = Field.finInsepDegree F K | null | true |
_private.Qq.Delab.0.Qq.Impl.failureOnError.match_1 | Qq.Delab | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive __do_lift | null | false |
Std.DTreeMap.Const.isSome_get?_eq_contains | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {a : α},
(Std.DTreeMap.Const.get? t a).isSome = t.contains a | null | true |
NumberField.mixedEmbedding.logMap_real_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {x : NumberField.mixedEmbedding.mixedSpace K},
NumberField.mixedEmbedding.norm x ≠ 0 →
∀ {c : ℝ}, c ≠ 0 → NumberField.mixedEmbedding.logMap (c • x) = NumberField.mixedEmbedding.logMap x | null | true |
CategoryTheory.PreZeroHypercover.Relation._sizeOf_1 | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{S : C} → {E : CategoryTheory.PreZeroHypercover S} → {i j : E.I₀} → [SizeOf C] → E.Relation i j → ℕ | null | false |
Subsingleton.uniqueTopologicalSpace._proof_1 | Mathlib.Topology.Order | ∀ {α : Type u_1} [Subsingleton α] (t : TopologicalSpace α), t = ⊥ | null | false |
isQuotientMap_quotient_mk' | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Setoid X}, Topology.IsQuotientMap Quotient.mk' | null | true |
Configuration.ProjectivePlane.two_lt_pointCount | Mathlib.Combinatorics.Configuration | ∀ (P : Type u_1) {L : Type u_2} [inst : Membership P L] [Configuration.ProjectivePlane P L] [Finite P] [Finite L]
(l : L), 2 < Configuration.pointCount P l | null | true |
Option.pmap_some | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {a : α} {p : α → Prop} {f : (a : α) → p a → β}
{h : ∀ (a_1 : α), some a = some a_1 → p a_1}, Option.pmap f (some a) h = some (f a ⋯) | null | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuse_1.match_8 | Mathlib.Tactic.DefEqAbuse | (motive : Except Lean.MessageData Unit × Lean.PersistentArray Lean.TraceElem → Sort u_1) →
(x : Except Lean.MessageData Unit × Lean.PersistentArray Lean.TraceElem) →
((permissiveResult : Except Lean.MessageData Unit) →
(permTraces : Lean.PersistentArray Lean.TraceElem) → motive (permissiveResult, permTrac... | null | false |
CategoryTheory.MorphismProperty.IsLocalAtTarget.mk_of_iff | Mathlib.CategoryTheory.MorphismProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
{K : CategoryTheory.Precoverage C} [P.RespectsIso],
(∀ ⦃X Y : C⦄ ⦃f : X ⟶ Y⦄ ⦃R : CategoryTheory.Presieve Y⦄,
R ∈ K.coverings Y →
(P f ↔
∀ {U : C} (g : U ⟶ Y) [inst_2 : CategoryTheory.Limits.HasP... | null | true |
Lean.pp.match | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool | null | true |
ProbabilityTheory.Kernel.lintegral_compProd | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ]
(η : ProbabilityTheory.Kernel (α × β) γ) [ProbabilityTheory.IsSFiniteKernel η] (a : α) {f : β × γ → ENNReal},
Measurabl... | Lebesgue integral against the composition-product of two kernels. | true |
instCommutativeInt32HOr | Init.Data.SInt.Bitwise | Std.Commutative fun x1 x2 => x1 ||| x2 | null | true |
MultilinearMap.instIsZeroApplyForall | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂], IsZeroApply (MultilinearMap R M₁ M₂) ((i : ι) → M₁ i) M₂ | null | true |
NumberField.FinitePlace | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | (K : Type u_4) → [inst : Field K] → [NumberField K] → Type (max 0 u_4) | A finite place of a number field `K` is a place associated to an embedding into a completion
with respect to a maximal ideal. | true |
Nat.getElem!_toList_rco_eq_add | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, i < n - m → (m...n).toList[i]! = m + i | null | true |
Function.Injective.generalizedBooleanAlgebra | Mathlib.Order.BooleanAlgebra.Basic | {α : Type u} →
{β : Type u_1} →
[inst : Max α] →
[inst_1 : Min α] →
[inst_2 : LE α] →
[inst_3 : LT α] →
[inst_4 : Bot α] →
[inst_5 : SDiff α] →
[inst_6 : GeneralizedBooleanAlgebra β] →
(f : α → β) →
Function.In... | Pullback a `GeneralizedBooleanAlgebra` along an injection. | true |
Lean.Diff.lcs._unsafe_rec | Lean.Util.Diff | {α : Type} → [BEq α] → [Hashable α] → Subarray α → Subarray α → Array α | null | false |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.parse.match_9 | Mathlib.Tactic.Module | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(AddCommMonoid «$M»)) →
(u₀ : Lean.Level) →
(fst : Q(Type u₀)) →
(fst_1 : Q(Semiring «$fst»)) →
(iRM₀ : Q(Module «$fst» «$M»)) →
(l₀ : Mathlib.Tactic.Module.qNF fst M) →
(_i : Q(AddCommGroup «$M»)) →
... | null | false |
Mathlib.Tactic.Monoidal.Mor₂OfExpr._unsafe_rec | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | Lean.Expr → Mathlib.Tactic.Monoidal.MonoidalM Mathlib.Tactic.BicategoryLike.Mor₂ | null | false |
BoolAlg.hom_ext_iff | Mathlib.Order.Category.BoolAlg | ∀ {X Y : BoolAlg} {f g : X ⟶ Y}, f = g ↔ BoolAlg.Hom.hom f = BoolAlg.Hom.hom g | null | true |
_private.Mathlib.RingTheory.PicardGroup.0.CommRing.Pic.mk_eq_iff.match_1_1 | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : CommRing.Pic R} (motive : Nonempty (M ≃ₗ[R] N.AsModule) → Prop) (x : Nonempty (M ≃ₗ[R] N.AsModule)),
(∀ (e : M ≃ₗ[R] N.AsModule), motive ⋯) → motive x | null | false |
map_zsmul | Mathlib.Algebra.Group.Hom.Defs | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (n : ℤ) (g : G), f (n • g) = n • f g | Additive group homomorphisms preserve integer scaling. | true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.decomposePerm._proof_5 | Mathlib.Tactic.Translate.Reorder | ∀ {n : ℕ} (i : ℕ) (j : Fin n), 2 ≤ [i, ↑j].length | null | false |
CochainComplex.HomComplex.Cochain.leftShift_smul | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {R : Type u_1}
[inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] {K L : CochainComplex C ℤ} {n : ℤ}
(γ : CochainComplex.HomComplex.Cochain K L n) (a n' : ℤ) (hn' : n + a = n') (x : R),
(x • γ).leftShift a n' hn' ... | null | true |
CochainComplex.mappingCone.descCocycle._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{n m : ℤ} (α : CochainComplex.HomComplex.Cochain F K m) (β : CochainComplex.HomComplex.Cocycle G K... | null | false |
Lean.Grind.CommRing.Expr.denote_toPoly_nc | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Ring α] (ctx : Lean.Grind.CommRing.Context α) (e : Lean.Grind.CommRing.Expr),
Lean.Grind.CommRing.Poly.denote ctx e.toPoly_nc = Lean.Grind.CommRing.Expr.denote ctx e | null | true |
Mathlib.Tactic.MkIff.Shape.casesOn | Mathlib.Tactic.MkIffOfInductiveProp | {motive : Mathlib.Tactic.MkIff.Shape → Sort u} →
(t : Mathlib.Tactic.MkIff.Shape) →
((variablesKept : List Bool) → (neqs : Option ℕ) → motive { variablesKept := variablesKept, neqs := neqs }) →
motive t | null | false |
MeasureTheory.IsAddFundamentalDomain.lintegral_eq_tsum_of_ac | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ] [Countable G]
{ν : MeasureTheory.Measure α},
MeasureTheory.IsAddFundamentalDomain G s μ →
ν.A... | null | true |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_30 | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_2} {E'' : Type u_3} {F : Type u_4} {H : Type u_5} {G : Type u_6} {E : Type u_1}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F]... | null | false |
_private.Mathlib.Algebra.Lie.Subalgebra.0.LieHom.equivRangeOfInjective._simp_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {α : Sort u_1} {p : α → Prop} {a : α} {h : p a} {a' : α} {h' : p a'}, (⟨a, h⟩ = ⟨a', h'⟩) = (a = a') | null | false |
Metric.cthickening_thickening_subset | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {ε : ℝ},
0 ≤ ε → ∀ (δ : ℝ) (s : Set α), Metric.cthickening ε (Metric.thickening δ s) ⊆ Metric.cthickening (ε + δ) s | For the equality, see `cthickening_thickening`. | true |
isotypicComponent_eq_top_iff | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} {S : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup S]
[inst_3 : Module R M] [inst_4 : Module R S] [IsSimpleModule R S] [IsSemisimpleModule R M],
isotypicComponent R M S = ⊤ ↔ IsIsotypicOfType R M S | null | true |
CategoryTheory.GrothendieckTopology.MayerVietorisSquare.mk_of_isPullback_toSquare | Mathlib.CategoryTheory.Sites.MayerVietorisSquare | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : CategoryTheory.HasWeakSheafify J (Type v)] (sq : CategoryTheory.Square C)
[inst_2 : CategoryTheory.Mono sq.f₂₄] [inst_3 : CategoryTheory.Mono sq.f₃₄] (h₁ : sq.IsPullback)
(h₂ : CategoryTheory.Sieve.ofTwo... | null | true |
CategoryTheory.Abelian.Preradical.ι | Mathlib.CategoryTheory.Abelian.Preradical.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.Abelian.Preradical C) → Φ.r ⟶ CategoryTheory.Functor.id C | The structure morphism `Φ.r ⟶ 𝟭 C` of a preradical `Φ`. | true |
_private.Mathlib.Data.Nat.Init.0.Nat.pincerRecursion.match_1.eq_3 | Mathlib.Data.Nat.Init | ∀ (motive : ℕ → ℕ → Sort u_1) (n n_1 : ℕ) (h_1 : (m : ℕ) → motive m 0) (h_2 : (n : ℕ) → motive 0 n)
(h_3 : (n n_2 : ℕ) → motive n.succ n_2.succ),
(match n.succ, n_1.succ with
| m, 0 => h_1 m
| 0, n => h_2 n
| n.succ, n_2.succ => h_3 n n_2) =
h_3 n n_1 | null | true |
MonCat.Hom.ext_iff | Mathlib.Algebra.Category.MonCat.Basic | ∀ {A B : MonCat} {x y : A.Hom B}, x = y ↔ x.hom' = y.hom' | null | true |
Lean.PersistentEnvExtensionDescr._sizeOf_inst | Lean.Environment | (α β σ : Type) → [SizeOf α] → [SizeOf β] → [SizeOf σ] → SizeOf (Lean.PersistentEnvExtensionDescr α β σ) | null | false |
QuadraticModuleCat.ofIso_hom | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {X Y : Type v} [inst_1 : AddCommGroup X] [inst_2 : Module R X]
[inst_3 : AddCommGroup Y] [inst_4 : Module R Y] {Q₁ : QuadraticForm R X} {Q₂ : QuadraticForm R Y}
(e : QuadraticMap.IsometryEquiv Q₁ Q₂), (QuadraticModuleCat.ofIso e).hom = QuadraticModuleCat.ofHom e.toIsometry | null | true |
Filter.NeBot.of_map₂_left | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β},
(Filter.map₂ m f g).NeBot → f.NeBot | null | true |
Lean.Grind.Linarith.Expr.denote.match_1 | Init.Grind.Ordered.Linarith | (motive : Lean.Grind.Linarith.Expr → Sort u_1) →
(x : Lean.Grind.Linarith.Expr) →
(Unit → motive Lean.Grind.Linarith.Expr.zero) →
((v : Lean.Grind.Linarith.Var) → motive (Lean.Grind.Linarith.Expr.var v)) →
((a b : Lean.Grind.Linarith.Expr) → motive (a.add b)) →
((a b : Lean.Grind.Linarith.... | null | false |
Lean.SCC.Data.onStack._default | Lean.Util.SCC | Bool | null | false |
AddCommGroup.modEq_zero_iff_eq_zsmul | Mathlib.Algebra.Group.ModEq | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a : G}, a ≡ 0 [PMOD p] ↔ ∃ z, a = z • p | null | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.inter._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap α β),
(↑(Std.DHashMap.Internal.Raw₀.inter ⟨m₁.inner, ⋯⟩ ⟨m₂.inner, ⋯⟩)).WF | null | false |
Std.Sat.CNF.BiEntails | Std.Sat.CNF.Entails | {α : Type u_1} → Std.Sat.CNF α → Std.Sat.CNF α → Prop | null | true |
_private.Lean.Meta.HasAssignableMVar.0.Lean.Meta.hasAssignableMVar.go | Lean.Meta.HasAssignableMVar | Lean.Expr → StateRefT' IO.RealWorld Lean.ExprSet Lean.MetaM Bool | null | true |
LinearRecurrence.repr_basis_eq | Mathlib.Algebra.LinearRecurrence | ∀ {R : Type u_1} [inst : CommSemiring R] (E : LinearRecurrence R) (u : ↥E.solSpace),
E.basis.repr u = Finsupp.ofSupportFinite (↑u ∘ Fin.val) ⋯ | The coordinates of a solution in the basis are its first `E.order` values | true |
_private.Mathlib.Tactic.Inclusion.ExtensionAPI.Attr.0.Inclusion.getHypothesisOpInfo | Mathlib.Tactic.Inclusion.ExtensionAPI.Attr | Lean.Name → Lean.MetaM (Array Lean.Meta.DiscrTree.Key × ℕ × Array Inclusion.HypArg × Array Inclusion.ParamArg) | Validate a hypothesis theorem and return its discrimination-tree path and argument metadata. | true |
_private.Lean.Widget.UserWidget.0.Lean.Widget.initFn.match_1._@.Lean.Widget.UserWidget.1579414551._hygCtx._hyg.2 | Lean.Widget.UserWidget | (motive : Option (Lean.Name × Lean.Widget.Module) → Sort u_1) →
(x : Option (Lean.Name × Lean.Widget.Module)) →
((val : Lean.Name × Lean.Widget.Module) → motive (some val)) →
((x : Option (Lean.Name × Lean.Widget.Module)) → motive x) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.