name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MonTypeEquivalenceMon.inverse._proof_12 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ {X Y Z : MonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Mon.Hom.mk'
(TypeCat.ofHom ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g))) ⋯ ⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Mon.Hom.mk' (TypeCat.ofHom ⇑(CategoryTheory.ConcreteCategory.hom f)) ⋯ ⋯)
... | null | false |
CategoryTheory.Lax.OplaxTrans.Modification.mk.inj | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {app : (a : B) → η.app a ⟶ θ.app a}
{naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | null | true |
LieDerivation.ofGradingSum._proof_3 | Mathlib.Algebra.Lie.Graded | ∀ {ι : Type u_2} {R : Type u_1} {L : Type u_3} [inst : DecidableEq ι] [inst_1 : AddCommMonoid ι] [inst_2 : CommRing R]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ℒ : ι → Submodule R L) [inst_5 : GradedLieAlgebra ℒ],
LieModule R (DirectSum ι fun i => ↥(ℒ i)) (DirectSum ι fun i => ↥(ℒ i)) | null | false |
NonUnitalSubring.mem_inf._simp_1 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {p p' : NonUnitalSubring R} {x : R}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') | null | false |
nnnorm_eq_zero' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : NormedGroup E] {a : E}, ‖a‖₊ = 0 ↔ a = 1 | null | true |
Std.ExtDHashMap.Const.getKey?_alter_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
(Std.ExtDHashMap.Const.alter m k f).getKey? k =
if (f (Std.ExtDHashMap.Const.get? m k)).isSome = true then some k else none | null | true |
UInt16.toNat_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a ^^^ b).toNat = a.toNat ^^^ b.toNat | null | true |
List.countP_lt_length_iff._simp_1 | Mathlib.Data.List.Count | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, (List.countP p l < l.length) = ∃ a ∈ l, p a = false | null | false |
Vector.findSome?_singleton | Init.Data.Vector.Find | ∀ {α : Type u_1} {β : Type u_2} {a : α} {f : α → Option β}, Vector.findSome? f #v[a] = f a | null | true |
conditionallyCompleteLatticeOfsSup._proof_3 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [H1 : PartialOrder α] [H2 : SupSet α] (bddAbove_pair : ∀ (a b : α), BddAbove {a, b})
(bddBelow_pair : ∀ (a b : α), BddBelow {a, b})
(isLUB_sSup : ∀ (s : Set α), BddAbove s → s.Nonempty → IsLUB s (sSup s)) (x : Set α),
x.Nonempty → BddBelow x → IsGLB x (sSup (lowerBounds x)) | null | false |
ZeroAtInftyContinuousMap.instAddZeroClass._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddZeroClass β]
[inst_3 : ContinuousAdd β] (a : ZeroAtInftyContinuousMap α β), a + 0 = a | null | false |
CompleteLatticeHomClass.toFrameHomClass | Mathlib.Order.Hom.CompleteLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
[inst_2 : CompleteLattice β] [CompleteLatticeHomClass F α β], FrameHomClass F α β | null | true |
Plausible.Testable.ctorIdx | Plausible.Testable | {p : Prop} → Plausible.Testable p → ℕ | null | false |
zpow_right_strictAnti | Mathlib.Algebra.Order.Group.Basic | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] {a : α},
a < 1 → StrictAnti fun n => a ^ n | null | true |
ProperlyDiscontinuousVAdd.rec | Mathlib.Topology.Algebra.ConstMulAction | {Γ : Type u_4} →
{T : Type u_5} →
[inst : TopologicalSpace T] →
[inst_1 : VAdd Γ T] →
{motive : ProperlyDiscontinuousVAdd Γ T → Sort u} →
((finite_disjoint_inter_image :
∀ {K L : Set T}, IsCompact K → IsCompact L → {γ | ((fun x => γ +ᵥ x) '' K ∩ L).Nonempty}.Finite) →
... | null | false |
instDecidableEqQuadraticAlgebra.decEq.match_1 | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} →
{a b : R} →
(motive : QuadraticAlgebra R a b → QuadraticAlgebra R a b → Sort u_2) →
(x x_1 : QuadraticAlgebra R a b) →
((a_1 a_2 b_1 b_2 : R) → motive { re := a_1, im := a_2 } { re := b_1, im := b_2 }) → motive x x_1 | null | false |
CategoryTheory.Functor.relativelyRepresentable.w | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X Y : D} {f : X ⟶ Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a ⟶ Y),
CategoryTheory.CategoryStruct.comp (hf.fst g) f = CategoryTheory.CategoryStruct... | null | true |
Submodule.moduleSet._proof_6 | Mathlib.Algebra.Algebra.Operations | ∀ (R : Type u_2) [inst : CommSemiring R] (A : Type u_1) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(P : Submodule R A), 0 • P = 0 | null | false |
Set.zero_smul_set_subset | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] (s : Set β), 0 • s ⊆ 0 | null | true |
Algebra.FormallyUnramified.of_surjective | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.FormallyUnramified R A] (f : A →ₐ[R] B),
Function.Surjective ⇑f → Algebra.FormallyUnramified R B | This holds in general for epimorphisms. | true |
Int.bmod_eq_self_sub_bdiv_mul | Init.Data.Int.DivMod.Lemmas | ∀ (x : ℤ) (m : ℕ), x.bmod m = x - x.bdiv m * ↑m | null | true |
DomAddAct.instVAddCommClassForall | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {β : Type u_2} {α : Type u_3} {N : Type u_4} [inst : VAdd M α] [inst_1 : VAdd N β],
VAddCommClass Mᵈᵃᵃ N (α → β) | null | true |
LieAdmissibleAlgebra.toModule | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | {R : Type u_1} →
{L : Type u_2} → {inst : CommRing R} → {inst_1 : LieAdmissibleRing L} → [self : LieAdmissibleAlgebra R L] → Module R L | null | true |
CategoryTheory.CommSq.LiftStruct.l | Mathlib.CategoryTheory.CommSq | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A B X Y : C} →
{f : A ⟶ X} →
{i : A ⟶ B} → {p : X ⟶ Y} → {g : B ⟶ Y} → {sq : CategoryTheory.CommSq f i p g} → sq.LiftStruct → (B ⟶ X) | The lift. | true |
Mathlib.Tactic._aux_Mathlib_Tactic_DefEqTransformations___elabRules_Mathlib_Tactic_tacticReduce___1 | Mathlib.Tactic.DefEqTransformations | Lean.Elab.Tactic.Tactic | `reduce at loc` completely reduces the given location.
This also exists as a `conv`-mode tactic.
This does the same transformation as the `#reduce` command.
| false |
Lean.PrettyPrinter.Delaborator.delabAppExplicitCore | Lean.PrettyPrinter.Delaborator.Builtins | Bool →
ℕ →
(Bool → Lean.PrettyPrinter.Delaborator.Delab) →
Array Lean.PrettyPrinter.Delaborator.ParamKind → Lean.PrettyPrinter.Delaborator.Delab | Delaborates a function application in explicit mode.
* If `insertExplicit` is true, then ensures the head syntax is wrapped with `@`.
* If `fieldNotation` is true, then allows the application to be pretty printed using field notation.
Field notation will not be used when `insertExplicit` is true.
| true |
Polynomial.card_support_trinomial | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] {k m n : ℕ},
k < m →
m < n →
∀ {x y z : R},
x ≠ 0 →
y ≠ 0 →
z ≠ 0 →
(Polynomial.C x * Polynomial.X ^ k + Polynomial.C y * Polynomial.X ^ m +
Polynomial.C z * Polynomial.X ^ n).support.card =
... | null | true |
exists_eq_smul_of_parallel | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {p₁ p₂ p₃ p₄ p₅ p₆ : P},
p₂ ∉ line[k, p₁, p₃] →
line[k, p₁, p₂].Parallel line[k, p₄, p₅] →
line[k, p₅, p₆].direction ≤ line[k, p₂, p₃].direction →
line[k,... | Given two triples of non-collinear points, if the lines determined by corresponding pairs of
points are parallel, then the vectors between corresponding pairs of points are all related by the
same nonzero scale factor. (The formal statement is slightly more general.) | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceE._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₃ : k ⟶ l) (n₁ n₂ : ℤ),
CategoryTheory.Limits.HasBinaryBiproduct ((X.H n₁).... | null | false |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} (motive : Turing.TM0to1.Λ' Γ Λ → Sort u_3) (q : Λ)
(h_1 : (q : Λ) → motive (Turing.TM0to1.Λ'.normal q))
(h_2 : (d : Turing.Dir) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.move d) q))
(h_3 : (a : Γ) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.write a) q)... | null | true |
Bundle.Trivialization.piecewise._proof_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_1} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e e' : Bundle.Trivialization F proj) (s : Set B),
e.baseSet ∩ frontier s = e'.baseSet ∩ frontier s →
e.source ∩ frontier (proj ⁻¹' s) = e'.source ∩ frontier (pro... | null | false |
Function.support_comp_eq_preimage | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Zero M] (g : κ → M) (f : ι → κ),
Function.support (g ∘ f) = f ⁻¹' Function.support g | null | true |
Std.TreeSet.Raw.max?_le_max?_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k km kmi : α},
t.max? = some km → (t.insert k).max?.get ⋯ = kmi → (cmp km kmi).isLE = true | null | true |
MeasureTheory.L1.integral_eq' | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} (𝕜 : Type u_4) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_1 : NormedSpace ℝ E] [inst_2 : NormedRing 𝕜] [inst_3 : Module 𝕜 E]
[inst_4 : IsBoundedSMul 𝕜 E] [inst_5 : SMulCommClass ℝ 𝕜 E] [inst_6 : CompleteSpace E]
(f : ↥(MeasureTheo... | null | true |
RegularExpression.matches'_zero | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1}, RegularExpression.matches' 0 = 0 | null | true |
SheafOfModules.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} → {X Y : SheafOfModules R} → [SizeOf C] → X.Hom Y → ℕ | null | false |
ContinuousOn.cpow | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f g : α → ℂ} {s : Set α},
ContinuousOn f s → ContinuousOn g s → (∀ a ∈ s, f a ∈ Complex.slitPlane) → ContinuousOn (fun x => f x ^ g x) s | null | true |
Std.Async.IO.AsyncRead.rec | Std.Async.IO | {α β : Type} →
{motive : Std.Async.IO.AsyncRead α β → Sort u} →
((read : α → Std.Async.Async β) → motive { read := read }) → (t : Std.Async.IO.AsyncRead α β) → motive t | null | false |
AddCircle.equivIco | Mathlib.Topology.Instances.AddCircle.Defs | {𝕜 : Type u_1} →
[inst : AddCommGroup 𝕜] →
(p : 𝕜) →
[inst_1 : LinearOrder 𝕜] →
[IsOrderedAddMonoid 𝕜] → [hp : Fact (0 < p)] → (a : 𝕜) → [Archimedean 𝕜] → AddCircle p ≃ ↑(Set.Ico a (a + p)) | The equivalence between `AddCircle p` and the half-open interval `[a, a + p)`, whose inverse
is the natural quotient map. | true |
_private.Std.Time.Date.ValidDate.0.PSigma.casesOn._arg_pusher | Std.Time.Date.ValidDate | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
MvPolynomial.expand_char | Mathlib.RingTheory.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (p : ℕ) [inst_1 : ExpChar R p] {f : MvPolynomial σ R},
(MvPolynomial.map (frobenius R p)) ((MvPolynomial.expand p) f) = f ^ p | **Alias** of `MvPolynomial.map_frobenius_expand`. | true |
_private.Mathlib.RingTheory.Frobenius.0.AlgHom.IsArithFrobAt.isArithFrobAt_localize._simp_1_3 | Mathlib.RingTheory.Frobenius | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {a : R} [inst_1 : I.IsTwoSided], (a ∈ I) = ((Ideal.Quotient.mk I) a = 0) | null | false |
Mathlib.Util.«_aux_Mathlib_Util_CompileInductive___elabRules_Mathlib_Util_commandCompile_def%__1» | Mathlib.Util.CompileInductive | Lean.Elab.Command.CommandElab | `compile_def% Foo.foo` adds compiled code for the definition `Foo.foo`.
This can be used for type class projections or definitions like `List._sizeOf_1`,
for which Lean does not generate compiled code by default
(since it is not used 99% of the time).
| false |
CategoryTheory.Pseudofunctor.hasCoeToOplax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → Coe (CategoryTheory.Pseudofunctor B C) (CategoryTheory.OplaxFunctor B C) | null | true |
Int32.toInt_not | Init.Data.SInt.Bitwise | ∀ (a : Int32), (~~~a).toInt = (-a.toInt - 1).bmod (2 ^ 32) | null | true |
PointedCone.lineal._proof_4 | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsOrderedRing R], PosMulMono R | null | false |
AddMonCat.coe_of | Mathlib.Algebra.Category.MonCat.Basic | ∀ (M : Type u) [inst : AddMonoid M], ↑(AddMonCat.of M) = M | null | true |
SubMulAction.subtype_eq_val | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] (p : SubMulAction R M), ⇑p.subtype = Subtype.val | null | true |
Lean.Elab.Term.State.mk.injEq | Lean.Elab.Term.TermElabM | ∀ (levelNames : List Lean.Name) (syntheticMVars : Lean.MVarIdMap Lean.Elab.Term.SyntheticMVarDecl)
(pendingMVars : List Lean.MVarId) (mvarErrorInfos : List Lean.Elab.Term.MVarErrorInfo)
(levelMVarErrorInfos : List Lean.Elab.Term.LevelMVarErrorInfo) (mvarArgNames : Lean.MVarIdMap Lean.Name)
(letRecsToLift : List L... | null | true |
_private.Lean.Environment.0.Lean.mkIRData | Lean.Environment | Lean.Environment → Lean.ModuleData | null | true |
Encodable.decode₂_is_partial_inv | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} [inst : Encodable α], Function.IsPartialInv Encodable.encode (Encodable.decode₂ α) | **Alias** of `Encodable.decode₂_isPartialInv`. | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.alterKey.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] (k : α) (f : Option (β k) → Option (β k))
(l : List ((a : α) × β a)),
Std.Internal.List.alterKey k f l =
match f (Std.Internal.List.getValueCast? k l) with
| none => Std.Internal.List.eraseKey k l
| some v => Std.Internal.List.insertE... | null | true |
Polynomial.Monic.degree_le_zero_iff_eq_one | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → (p.degree ≤ 0 ↔ p = 1) | null | true |
LocallyFiniteOrder.ofOrderIsoClass | Mathlib.Order.Interval.Finset.Defs | {F : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
[inst : Preorder M] →
[inst_1 : Preorder N] →
[inst_2 : EquivLike F M N] → [OrderIsoClass F M N] → F → [LocallyFiniteOrder N] → LocallyFiniteOrder M | A `LocallyFiniteOrder` can be transferred across an order isomorphism. | true |
_private.Mathlib.Data.Finset.Basic.0.Multiset.toFinset_nonempty._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} {s : Finset α}, s.Nonempty = (s ≠ ∅) | null | false |
Ordinal.nfp_mul_eq_opow_omega0 | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ {a b : Ordinal.{u_1}}, 0 < b → b ≤ a ^ Ordinal.omega0 → Ordinal.nfp (fun x => a * x) b = a ^ Ordinal.omega0 | null | true |
CategoryTheory.Limits.reflectsCofilteredLimitsOfSize_of_univLE | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [UnivLE.{w, w'}] [UnivLE.{w₂, w₂'}]
[CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.{w', w₂', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.ReflectsCofilteredL... | A functor reflecting larger cofiltered limits also reflects smaller cofiltered limits. | true |
instFullWitness | Mathlib.CategoryTheory.UnivLE | ∀ [inst : UnivLE.{max u v, v}], UnivLE.witness.Full | null | true |
_private.Mathlib.Topology.ContinuousMap.CompactlySupported.0.CompactlySupportedContinuousMap.nnrealPart_smul_neg._simp_1_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b : R} [ExistsAddOfLE R] [MulPosMono R] [AddRightMono R]
[AddRightReflectLE R], a ≤ 0 → b ≤ 0 → (0 ≤ a * b) = True | null | false |
CategoryTheory.ShortComplex.homologyFunctorOpNatIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.CategoryWithHomology C] (S : (CategoryTheory.ShortComplex C)ᵒᵖ), (Opposite.unop S).op.HasHomology | null | false |
Lean.Parser.ParserExtension.Entry.category.sizeOf_spec | Lean.Parser.Extension | ∀ (catName declName : Lean.Name) (behavior : Lean.Parser.LeadingIdentBehavior),
sizeOf (Lean.Parser.ParserExtension.Entry.category catName declName behavior) =
1 + sizeOf catName + sizeOf declName + sizeOf behavior | null | true |
Std.Tactic.BVDecide.BVExpr.Cache.Key.w | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | Std.Tactic.BVDecide.BVExpr.Cache.Key → ℕ | null | true |
CategoryTheory.MorphismProperty.Over.pullbackComp._proof_2 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P Q : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) [inst_2 : P.IsStableUnderBaseChangeAlong f]
[inst_3 : P.IsStableUnderBaseChangeAlong g] [inst_4 : P.HasPullbacksAlong f] [inst_5 : P.HasPullbacks... | null | false |
SimpleGraph.induceHom | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} →
{W : Type u_2} →
{G : SimpleGraph V} →
{G' : SimpleGraph W} →
{s : Set V} →
{t : Set W} → (φ : G →g G') → Set.MapsTo (⇑φ) s t → SimpleGraph.induce s G →g SimpleGraph.induce t G' | The restriction of a morphism of graphs to induced subgraphs. | true |
Set.MapsTo.vadd_set | Mathlib.GroupTheory.GroupAction.Pointwise | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} {F : Type u_4} [inst : VAdd M α] [inst_1 : VAdd M β]
[inst_2 : FunLike F α β] [AddActionHomClass F M α β] {f : F} {s : Set α} {t : Set β},
Set.MapsTo (⇑f) s t → ∀ (c : M), Set.MapsTo (⇑f) (c +ᵥ s) (c +ᵥ t) | null | true |
Codisjoint.map | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : FunLike F α β]
[inst_3 : OrderTop α] [inst_4 : OrderTop β] [TopHomClass F α β] [SupHomClass F α β] {a b : α} (f : F),
Codisjoint a b → Codisjoint (f a) (f b) | null | true |
NonUnitalStarSubalgebra.map | Mathlib.Algebra.Star.NonUnitalSubalgebra | {F : Type v'} →
{R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : Module ... | Transport a non-unital star subalgebra via a non-unital star algebra homomorphism. | true |
PrimeSpectrum.instNonemptyOfNontrivial | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u} [inst : CommSemiring R] [Nontrivial R], Nonempty (PrimeSpectrum R) | null | true |
_private.Mathlib.NumberTheory.LSeries.MellinEqDirichlet.0.hasSum_mellin_pi_mul_sq'._simp_1_5 | Mathlib.NumberTheory.LSeries.MellinEqDirichlet | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Real.Angle.sign_two_nsmul_eq_neg_sign_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, (2 • θ).sign = -θ.sign ↔ θ = 0 ∨ Real.pi / 2 < |θ.toReal| | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms.0.CategoryTheory.Limits.HasZeroMorphisms.ext_aux | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I J : CategoryTheory.Limits.HasZeroMorphisms C),
(∀ (X Y : C), Zero.zero = Zero.zero) → I = J | This lemma will be immediately superseded by `ext`, below. | true |
List.Perm.eq_reverse_of_sortedLE_of_sortedGE | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : PartialOrder α] {l₁ l₂ : List α}, l₁.Perm l₂ → l₁.SortedLE → l₂.SortedGE → l₁ = l₂.reverse | null | true |
Matrix.IsPrimitive.mk._flat_ctor | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : Fintype n] [inst_3 : DecidableEq n]
{A : Matrix n n R}, (∀ (i j : n), 0 ≤ A i j) → (∃ k > 0, ∀ (i j : n), 0 < (A ^ k) i j) → A.IsPrimitive | null | false |
Lean.Compiler.LCNF.FunDecl.mk.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId : Lean.FVarId} →
{binderName : Lean.Name} →
{params : Array (Lean.Compiler.LCNF.Param pu)} →
{type : Lean.Expr} →
{value : Lean.Compiler.LCNF.Code pu} →
{fvarId' : Lean.FVarId} →
{binderName... | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.equivIntOfUnique._simp_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
Filter.Germ.instMonoid.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : Monoid M],
Filter.Germ.instMonoid =
{ toSemigroup := Filter.Germ.instSemigroup, toOne := Filter.Germ.instOne, one_mul := ⋯, mul_one := ⋯,
npow := fun n a => a ^ n, npow_zero := ⋯, npow_succ := ⋯ } | null | true |
nonempty_linearEquiv_of_lift_rank_eq | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[Module.Free R M] [inst_4 : AddCommMonoid M'] [inst_5 : Module R M'] [Module.Free R M'] [StrongRankCondition R],
Cardinal.lift.{v', v} (Module.rank R M) = Cardinal.lift.{v, v'} (Module.rank R M') → Nonemp... | Two vector spaces are isomorphic if they have the same dimension. | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_316 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
List.idxOfNth w_1 [g a, g (g a)] (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[1] + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, ... | null | false |
CategoryTheory.Distributive._aux_Mathlib_CategoryTheory_Distributive_Monoidal___unexpand_CategoryTheory_leftDistrib_1 | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.LaxBraidedFunctor.comp_hom | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F G H : Categor... | null | true |
Aesop.evalAesop | Aesop.Main | Lean.Elab.Tactic.Tactic | null | true |
MeasureTheory.measure_sdiff_le_iff_le_add | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.NullMeasurableSet s μ → s ⊆ t → μ s ≠ ⊤ → ∀ {ε : ENNReal}, μ (t \ s) ≤ ε ↔ μ t ≤ μ s + ε | null | true |
CategoryTheory.kernelCokernelCompSequence.snakeInput_L₁_g | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.kernelCokernelCompSequence.snakeInput f g).L₁.g = CategoryTheory.Limits.biprod.snd | null | true |
Matrix.isSymm_transpose_iff | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.transpose.IsSymm ↔ A.IsSymm | null | true |
WCovBy.Ioo_eq | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ⩿ b → Set.Ioo a b = ∅ | null | true |
PointwiseConvergenceCLM.coeLMₛₗ | Mathlib.Topology.Algebra.Module.Spaces.PointwiseConvergenceCLM | {𝕜₁ : Type u_4} →
{𝕜₂ : Type u_5} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
(σ : 𝕜₁ →+* 𝕜₂) →
(E : Type u_7) →
(F : Type u_8) →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : AddCommGroup... | Coercion from `E →SLₚₜ[σ] F` to `E →ₛₗ[σ] F` as a `𝕜₂`-linear map. | true |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.homEquiv_unit._autoParam | Mathlib.CategoryTheory.Adjunction.Basic | Lean.Syntax | null | false |
Real.cosPartialEquiv._proof_5 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ θ ∈ Set.Icc 0 Real.pi, θ ≤ Real.pi | null | false |
MonCat.HasLimits.limitConeIsLimit._proof_2 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cone F) (v : ((CategoryTheory.forget MonCat).mapCone s).pt) {j j' : J} (f : j ⟶ j'),
(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp (((CategoryTheory.forg... | null | false |
AddSubgroup.relIndex_eq_one._simp_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, (H.relIndex K = 1) = (K ≤ H) | null | false |
AlgebraicGeometry.Scheme.Hom | Mathlib.AlgebraicGeometry.Scheme | AlgebraicGeometry.Scheme → AlgebraicGeometry.Scheme → Type u_1 | A morphism between schemes is a morphism between the underlying locally ringed spaces. | true |
Lean.DeclarationRanges.mk.inj | Lean.Data.DeclarationRange | ∀ {range selectionRange range_1 selectionRange_1 : Lean.DeclarationRange},
{ range := range, selectionRange := selectionRange } = { range := range_1, selectionRange := selectionRange_1 } →
range = range_1 ∧ selectionRange = selectionRange_1 | null | true |
AdicCompletion.map_of | Mathlib.RingTheory.AdicCompletion.Functoriality | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_3} [inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : M),
(AdicCompletion.map I f) ((AdicCompletion.of I M) x) = (AdicCompletion.of I N) (f x) | null | true |
ENNReal.le_toNNReal_of_coe_le | Mathlib.Data.ENNReal.Real | ∀ {a : ENNReal} {p : NNReal}, ↑p ≤ a → a ≠ ⊤ → p ≤ a.toNNReal | null | true |
Std.DTreeMap.toList_rci | Std.Data.DTreeMap.Slice | ∀ {α : Type u} {β : α → Type v} (cmp : autoParam (α → α → Ordering) Std.DTreeMap.toList_rci._auto_1) [Std.TransCmp cmp]
{t : Std.DTreeMap α β cmp} {bound : α},
Std.Slice.toList (Std.Rci.Sliceable.mkSlice t bound...*) = List.filter (fun e => (cmp e.fst bound).isGE) t.toList | null | true |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.isCoprime_biInf._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, IsCoprime I J = (I + J = 1) | null | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.u₁ | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} →
FermatLastTheoremForThreeGen.Solution✝ hζ →
[inst_1 : NumberField K] → [IsCyclotomicExtension {3} ℚ K] → (NumberField.RingOfIntegers K)ˣ | null | true |
Int.dvd_negSucc._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} {b : ℕ}, (a ∣ Int.negSucc b) = (a ∣ ↑(b + 1)) | null | false |
CategoryTheory.ReflexiveRelation.map | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
CategoryTheory.ReflexiveRelation p₁ p₂ →
(F : CategoryTheory.Functor C D) →
[CategoryT... | Given a functor `F : C ⥤ D`, if `F.map p₁` and `F.map p₂` form a jointly monic pair of
morphisms, then `F` preserves reflexive relations. | true |
ContMDiff.smul | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {H' : Type u_4}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.