name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SetRel.equivFixedPoints._proof_6 | Mathlib.Order.Rel.GaloisConnection | ∀ {α : Type u_2} {β : Type u_1} (R : SetRel α β) (I : ↑R.rightFixedPoints),
(fun x =>
match x with
| ⟨J, property⟩ => ⟨R.leftDual J, ⋯⟩)
((fun x =>
match x with
| ⟨I, property⟩ => ⟨R.rightDual I, ⋯⟩)
I) =
I | null | false |
instRingObjOppositeOpensCarrierOfPresheafSmoothSheaf._proof_22 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | null | false |
Lean.Elab.Term.GeneralizeResult.mk.injEq | Lean.Elab.Match | ∀ (discrs : Array Lean.Elab.Term.Discr) (toClear : Array Lean.FVarId) (matchType : Lean.Expr)
(altViews : Array Lean.Elab.Term.TermMatchAltView) (refined : Bool) (discrs_1 : Array Lean.Elab.Term.Discr)
(toClear_1 : Array Lean.FVarId) (matchType_1 : Lean.Expr) (altViews_1 : Array Lean.Elab.Term.TermMatchAltView)
(... | null | true |
MvPolynomial.optionEquivLeft_symm_X | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) [inst : CommSemiring R],
(MvPolynomial.optionEquivLeft R S₁).symm Polynomial.X = MvPolynomial.X none | null | true |
Affine.Simplex.touchpoint_mem_affineSpan | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1)))
(i : Fin (n + 1)), s.touchpoint signs i ∈ affineSpan ℝ (Set.range (s.faceOpposi... | null | true |
exteriorPower.presentation.relations_G | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ (R : Type u) [inst : CommRing R] (ι : Type u_4) [inst_1 : DecidableEq ι] (M : Type u_5) [inst_2 : AddCommGroup M]
[inst_3 : Module R M], (exteriorPower.presentation.relations R ι M).G = (ι → M) | null | true |
CategoryTheory.Equivalence.instPowInt | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → Pow (C ≌ C) ℤ | null | true |
_private.Mathlib.Analysis.Convex.Gauge.0.gauge_closure_zero._simp_1_3 | Mathlib.Analysis.Convex.Gauge | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | null | false |
CategoryTheory.ChosenPullbacksAlong.pullbackMap_comp._proof_10 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Z X : C} {g : Z ⟶ X} {Z' X' Z'' X'' : C} {g' : Z' ⟶ X'}
{g'' : Z'' ⟶ X''} {γ₂ : Z' ⟶ Z} {γ₃ : X' ⟶ X} {δ₂ : Z'' ⟶ Z'} {δ₃ : X'' ⟶ X'},
autoParam (CategoryTheory.CategoryStruct.comp g' γ₃ = CategoryTheory.CategoryStruct.comp γ₂ g)
CategoryTheory.C... | null | false |
CategoryTheory.Subobject.factors_iff | Mathlib.CategoryTheory.Subobject.FactorThru | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (P : CategoryTheory.Subobject Y) (f : X ⟶ Y),
P.Factors f ↔ (CategoryTheory.Subobject.representative.obj P).Factors f | null | true |
Std.Http.RequestTarget.originForm.noConfusion | Std.Http.Data.URI.Basic | {P : Sort u} →
{path : Std.Http.URI.Path} →
{query : Option Std.Http.URI.Query} →
{path' : Std.Http.URI.Path} →
{query' : Option Std.Http.URI.Query} →
Std.Http.RequestTarget.originForm path query = Std.Http.RequestTarget.originForm path' query' →
(path = path' → query = query' ... | null | false |
_private.Lean.Linter.AmbiguousOpen.0.Lean.Linter.scopeCandidates._sparseCasesOn_1 | Lean.Linter.AmbiguousOpen | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Antitone.const_smul | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β] [inst_3 : Zero α]
[PosSMulMono α β] {γ : Type u_3} [inst_5 : Preorder γ] {f : γ → β}, Antitone f → 0 ≤ a → Antitone fun x => a • f x | Scalar multiplication on the left by a nonnegative element preserves antitonicity. | true |
LocalizedModule.map.eq_1 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {N : Type u_3} [inst_3 : AddCommMonoid N] [inst_4 : Module R N],
LocalizedModule.map S =
IsLocalizedModule.mapExtendScalars S (LocalizedModule.mkLinearMap S M) (LocalizedModule.mkLinearMap ... | null | true |
FiniteIndexNormalAddSubgroup.comap._proof_1 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H] (f : G →+ H)
(K : FiniteIndexNormalAddSubgroup H), (AddSubgroup.comap f K.toAddSubgroup).Normal | null | false |
_private.Batteries.Data.List.Lemmas.0.List.beq_iff_exists_findIdxNth._proof_1_3 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {x : α} [inst : BEq α] {xs : List α} {h : i < xs.length},
(xs[i] == x) = true → List.idxOfNth x xs (List.countBefore x xs i) = i | null | false |
continuous_fst | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], Continuous Prod.fst | null | true |
Prod.instCompletelyDistribLattice._proof_6 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompletelyDistribLattice α] [inst_1 : CompletelyDistribLattice β] (a : α × β),
a ⇨ ⊥ = aᶜ | null | false |
LowerSemicontinuousOn.isClosed_re_epigraph | Mathlib.Analysis.Convex.Approximation | ∀ {𝕜 : Type u_1} {E : Type u_2} {s : Set E} {φ : E → ℝ} [inst : RCLike 𝕜] [inst_1 : TopologicalSpace E],
IsClosed s → LowerSemicontinuousOn φ s → IsClosed {p | p.1 ∈ s ∧ φ p.1 ≤ RCLike.re p.2} | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop._proof_3 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) (c : C)
(d : D),
(F.obj c).unmop.map (CategoryTheory.CategoryStruct.id d) = CategoryTheory.CategoryStruct.id ((F.obj c).unmop... | null | false |
QuadraticModuleCat.concreteCategory._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : QuadraticModuleCat R} (f : X ⟶ Y), { toIsometry' := f.toIsometry' } = f | null | false |
SeminormFamily.addGroupFilterBasis | Mathlib.Analysis.LocallyConvex.WithSeminorms | {R : Type u_1} →
{E : Type u_6} →
{ι : Type u_9} →
[inst : SeminormedRing R] →
[inst_1 : AddCommGroup E] → [inst_2 : Module R E] → SeminormFamily R E ι → AddGroupFilterBasis E | The `addGroupFilterBasis` induced by the filter basis `Seminorm.basisSets`. | true |
_private.Mathlib.Algebra.Order.BigOperators.Group.Finset.0.Multiset.finsetSum_eq_sup_iff_disjoint._simp_1_13 | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {a b c : Prop}, (a ∧ b ∧ c) = ((a ∧ b) ∧ c) | null | false |
CategoryTheory.Sheaf.χ_hom | Mathlib.CategoryTheory.Topos.Sheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
{F G : CategoryTheory.Sheaf J (Type (max u v))} (m : F ⟶ G) [inst_1 : CategoryTheory.Mono m],
(CategoryTheory.Sheaf.χ m).hom = CategoryTheory.Subfunctor.lift (CategoryTheory.Presheaf.χ m.hom) ⋯ | null | true |
PrimeSpectrum.ConstructibleSetData.isConstructible_toSet | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} [inst : CommSemiring R] (S : PrimeSpectrum.ConstructibleSetData R), Topology.IsConstructible S.toSet | null | true |
nnnorm_algebraMap | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_1} (𝕜' : Type u_2) [inst : NormedField 𝕜] [inst_1 : SeminormedRing 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜']
(x : 𝕜), ‖(algebraMap 𝕜 𝕜') x‖₊ = ‖x‖₊ * ‖1‖₊ | null | true |
Monoid.CoprodI.Word.equivPair_tail_eq_inv_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} [inst : DecidableEq ι] {G : ι → Type u_4} [inst_1 : (i : ι) → Group (G i)]
[inst_2 : (i : ι) → DecidableEq (G i)] {i : ι} (w : Monoid.CoprodI.Word G),
((Monoid.CoprodI.Word.equivPair i) w).tail = (Monoid.CoprodI.of ((Monoid.CoprodI.Word.equivPair i) w).head)⁻¹ • w | null | true |
CategoryTheory.ShortComplex.Hom.id_τ₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.Hom.id S).τ₃ = CategoryTheory.CategoryStruct.id S.X₃ | null | true |
CategoryTheory.Functor.homologicalKernel | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | {C : Type u_1} →
{A : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.HasShift C ℤ] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] → CategoryTheory.Functor C A → CategoryTheory.ObjectProperty C | The kernel of a homological functor `F : C ⥤ A` is the strictly full
triangulated subcategory consisting of objects `X` such that
for all `n : ℤ`, `F.obj (X⟦n⟧)` is zero. | true |
Std.DHashMap.Const.get_union_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁.union m₂},
Std.DHashMap.Const.get (m₁.union m₂) k h' = Std.DHashMap.Const.get m₂ k ⋯ | null | true |
Fin.succFunctor_map | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (n : ℕ) {x x_1 : Fin n} (hij : x ⟶ x_1), (Fin.succFunctor n).map hij = CategoryTheory.homOfLE ⋯ | null | true |
ContinuousAt.mabs | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : LinearOrder G] [IsOrderedMonoid G]
[OrderTopology G] {X : Type u_2} [inst_5 : TopologicalSpace X] {f : X → G} {x : X},
ContinuousAt f x → ContinuousAt (fun x => |f x|ₘ) x | null | true |
Nat.Internal.Linear.Expr.denote._f | Init.Data.Nat.Internal.Linear | Nat.Internal.Linear.Context → (x : Nat.Internal.Linear.Expr) → Nat.Internal.Linear.Expr.below x → ℕ | null | false |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.totallyBounded_interUnionBalls._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | null | false |
Set.prod_quotient_preimage_eq_image | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} [s : Setoid α] (g : Quotient s → β) {h : α → β},
h = g ∘ Quotient.mk'' →
∀ (r : Set (β × β)), {x | (g x.1, g x.2) ∈ r} = (fun a => (⟦a.1⟧, ⟦a.2⟧)) '' (fun a => (h a.1, h a.2)) ⁻¹' r | null | true |
PrimeSpectrum.primeSpectrumProd._proof_2 | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S],
Function.Bijective (PrimeSpectrum.primeSpectrumProdOfSum R S) | null | false |
_private.Batteries.Data.List.Basic.0.List.toChunks.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → ℕ → List α → Array α → Array (List α) → List (List α) | null | false |
Lean.IR.Param.mk.inj | Lean.Compiler.IR.Basic | ∀ {x : Lean.IR.VarId} {borrow : Bool} {ty : Lean.IR.IRType} {x_1 : Lean.IR.VarId} {borrow_1 : Bool}
{ty_1 : Lean.IR.IRType},
{ x := x, borrow := borrow, ty := ty } = { x := x_1, borrow := borrow_1, ty := ty_1 } →
x = x_1 ∧ borrow = borrow_1 ∧ ty = ty_1 | null | true |
NNReal.summable_rpow_inv | Mathlib.Analysis.PSeries | ∀ {p : ℝ}, (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p | null | true |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.inferAppType.match_1 | Lean.Compiler.LCNF.InferType | (motive : (pu : Lean.Compiler.LCNF.Purity) → Array (Lean.Compiler.LCNF.Arg pu) → Sort u_1) →
(pu : Lean.Compiler.LCNF.Purity) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
((args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive Lean.Compiler.LCNF.Purity.pure args) →
... | null | false |
Bool.rec.eq._@.Mathlib.Util.CompileInductive.3618634379._hygCtx._hyg.4 | Mathlib.Util.CompileInductive | @Bool.rec = @Bool.rec✝ | null | false |
Lean.Parser.Command.init_quot.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
MeasureTheory.QuasiMeasurePreserving.preimage_ae_eq | Mathlib.MeasureTheory.Measure.QuasiMeasurePreserving | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μa : MeasureTheory.Measure α}
{μb : MeasureTheory.Measure β} {f : α → β} {s t : Set β},
MeasureTheory.QuasiMeasurePreserving f μa μb → s =ᵐ[μb] t → f ⁻¹' s =ᵐ[μa] f ⁻¹' t | null | true |
_private.Mathlib.Topology.Sion.0.Sion.disjoint_sublevelLeft | Mathlib.Topology.Sion | ∀ {E : Type u_1} {F : Type u_2} {β : Type u_3} [inst : LinearOrder β] {X : Set E} {Y : Set F} {f : E → F → β} {a : E}
{b : β} {y y' : ↑Y},
(∀ x ∈ X, max (f a ↑y) (f a ↑y') ≤ max (f x ↑y) (f x ↑y')) →
b < max (f a ↑y) (f a ↑y') → Disjoint (Sion.sublevelLeft✝ X f b ↑y) (Sion.sublevelLeft✝ X f b ↑y') | Disjointness criterion for two `sublevelLeft` at different values of the parameter | true |
List.rotate_append_length_eq | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l l' : List α), (l ++ l').rotate l.length = l' ++ l | null | true |
AddCon.kerLift_injective | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : AddZeroClass M] [inst_1 : AddZeroClass P] (f : M →+ P),
Function.Injective ⇑(AddCon.kerLift f) | An `AddMonoid` homomorphism `f` induces an injective homomorphism on the quotient
by `f`'s kernel. | true |
CategoryTheory.Discrete.monoidal._proof_13 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u_1) [inst : Monoid M] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : CategoryTheory.Discrete M} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
(f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (CategoryTheory.Discrete.eqToIso ⋯).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Discrete.eqToIso ⋯).hom (Cat... | null | false |
TensorProduct.ite_tmul | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (x₁ : M) (x₂ : N) (P : Prop)
[inst_5 : Decidable P], (if P then x₁ else 0) ⊗ₜ[R] x₂ = if P then x₁ ⊗ₜ[R] x₂ else 0 | null | true |
_private.Mathlib.Combinatorics.Schnirelmann.0.add_eq_univ_of_one_le_schirelmannDensity_add_schnirelmannDensity._simp_1_7 | Mathlib.Combinatorics.Schnirelmann | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {a : α}, (Sum.inl a ∈ s.disjSum t) = (a ∈ s) | null | false |
CategoryTheory.MorphismProperty.Under.instHasFiniteColimitsTopOfHasFiniteWidePushouts | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P : CategoryTheory.MorphismProperty T) (X : T)
[CategoryTheory.Limits.HasPushouts T] [P.IsStableUnderComposition] [P.ContainsIdentities]
[P.IsStableUnderCobaseChange] [P.HasOfPrecompProperty P] [CategoryTheory.Limits.HasFiniteWidePushouts T],
Categor... | null | true |
Odd | Mathlib.Algebra.Ring.Parity | {α : Type u_2} → [Semiring α] → α → Prop | An element `a` of a semiring is odd if there exists `k` such `a = 2*k + 1`. | true |
RingQuot._sizeOf_inst | Mathlib.Algebra.RingQuot | {R : Type uR} →
{inst : Semiring R} → (r : R → R → Prop) → [SizeOf R] → [(a a_1 : R) → SizeOf (r a a_1)] → SizeOf (RingQuot r) | null | false |
Std.Net.InterfaceAddress | Std.Net.Addr | Type | Represents an interface address, including details such as the interface name,
whether it is internal, the associated address, and the network mask.
| true |
Real.sqrtTwoAddSeries.eq_def | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (x_1 : ℕ),
x.sqrtTwoAddSeries x_1 =
match x_1 with
| 0 => x
| n.succ => √(2 + x.sqrtTwoAddSeries n) | null | true |
StrictMonoOn.monotoneOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictMonoOn f s → MonotoneOn f s | null | true |
CategoryTheory.Functor.IsCoverDense.Types.presheafIso.congr_simp | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {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] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} [inst_2 : G.IsCoverDense K] [inst_3 : G.IsLocallyFull K]
{ℱ ℱ' : CategoryTheory.Sheaf K (Type v)} (i i_1 : G.op... | null | true |
CategoryTheory.MorphismProperty.Comma.Hom.comp._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_2, u_5} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_3, u_6} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | null | false |
Finset.image_neg | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq β] [inst_2 : AddGroup α]
[inst_3 : SubtractionMonoid β] [inst_4 : FunLike F α β] [AddMonoidHomClass F α β] (f : F) (s : Finset α),
Finset.image (⇑f) (-s) = -Finset.image (⇑f) s | null | true |
MaximalSpectrum.mapPiLocalization.congr_simp | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f f_1 : R →+* S) (e_f : f = f_1)
(hf : Function.Bijective ⇑f), MaximalSpectrum.mapPiLocalization f hf = MaximalSpectrum.mapPiLocalization f_1 ⋯ | null | true |
_private.Mathlib.RingTheory.Extension.Presentation.Core.0.Algebra.SubmersivePresentation.ofHasCoeffs._simp_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Submodule.mem_span_singleton_of_inner_eq_zero_of_inner_eq_zero | Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[Fact (Module.finrank 𝕜 E = 2)] {u v w : E}, v ≠ 0 → w ≠ 0 → inner 𝕜 v u = 0 → inner 𝕜 v w = 0 → u ∈ 𝕜 ∙ w | If a nonzero vector `w` and a vector `u` are both orthogonal to the same nonzero vector `v`
in a two-dimensional inner product space, then `u` lies in the span of `w`. | true |
Int8.and_assoc | Init.Data.SInt.Bitwise | ∀ (a b c : Int8), a &&& b &&& c = a &&& (b &&& c) | null | true |
_private.Mathlib.RingTheory.Regular.ProjectiveDimension.0.ModuleCat.projectiveDimension_quotSMulTop_eq_succ_of_isSMulRegular._simp_1_12 | Mathlib.RingTheory.Regular.ProjectiveDimension | ∀ {A B : AddCommGrpCat} (f : A ⟶ B), CategoryTheory.Epi f = Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f) | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Derivative.0.MvPowerSeries.pderiv_X_self._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Derivative | ∀ {M : Type u_4} [inst : AddMonoid M] [IsRightCancelAdd M] {a b : M}, (a + b = b) = (a = 0) | null | false |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass_add | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y) {n : ℕ}
(x y : CategoryTheory.Abelian.Ext X Y n),
R.extEquivCohomologyClass (x + y) = R.extEquivCohomologyClass x + R.extEquivCohomol... | null | true |
_private.Lean.Meta.Tactic.FunIndCollect.0.Lean.Meta.FunInd.collect.unsafe_1 | Lean.Meta.Tactic.FunIndCollect | Lean.Meta.FunIndInfo → Lean.MVarId → Lean.MetaM (Array Lean.Expr) | null | true |
MulAlgebraNorm.ext_iff | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : outParam (Type u_1)} {S : outParam (Type u_2)} [inst : SeminormedCommRing R] [inst_1 : Ring S]
[inst_2 : Algebra R S] {p q : MulAlgebraNorm R S}, p = q ↔ ∀ (x : S), p x = q x | null | true |
addCommutator_eq_closure | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : AddGroup G], addCommutator G = AddSubgroup.closure (addCommutatorSet G) | null | true |
SimpleGraph.edgeDensity.eq_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_4} (G : SimpleGraph α) [inst : DecidableRel G.Adj], G.edgeDensity = Rel.edgeDensity G.Adj | null | true |
Homeomorph.piCongrLeft_symm_apply | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_5} {ι' : Type u_6} {Y : ι' → Type u_7} [inst : (j : ι') → TopologicalSpace (Y j)] (e : ι ≃ ι'),
⇑(Homeomorph.piCongrLeft e).symm = fun x1 x2 => x1 (e x2) | null | true |
Lean.JsonRpc.RequestID.num.sizeOf_spec | Lean.Data.JsonRpc | ∀ (n : Lean.JsonNumber), sizeOf (Lean.JsonRpc.RequestID.num n) = 1 + sizeOf n | null | true |
CategoryTheory.Limits.hasStrongEpiImages_of_hasStrongEpiMonoFactorisations | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C], CategoryTheory.Limits.HasStrongEpiImages C | If we constructed our images from strong epi-mono factorisations, then these images are
strong epi images. | true |
Polynomial.instCommRingUniversalFactorizationRing._proof_45 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
autoParam (∀ (n_1 : ℕ), IntCast.intCast ↑n_1 = ↑n_1) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
Fintype.expect_ite_zero | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {M : Type u_4} [inst : Fintype ι] [inst_1 : AddCommMonoid M] [inst_2 : Module ℚ≥0 M] (p : ι → Prop)
[inst_3 : DecidablePred p],
(∀ (i j : ι), p i → p j → i = j) →
∀ (a : M), (Finset.univ.expect fun i => if p i then a else 0) = if ∃ i, p i then (↑(Fintype.card ι))⁻¹ • a else 0 | null | true |
RightCosetEquivalence | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [Mul α] → Set α → α → α → Prop | Equality of two right cosets `s * a` and `s * b`. | true |
ENNReal.inv_eq_zero | Mathlib.Basic.ENNReal.Inv | ∀ {a : ENNReal}, a⁻¹ = 0 ↔ a = ⊤ | null | true |
MagmaCat.instCategory._proof_3 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {W X Y Z : MagmaCat} (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 |
Lean.Elab.WF.GuessLex.RecCallCache.mk'' | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Name →
Option Lean.Elab.DecreasingBy →
Array Lean.Elab.WF.GuessLex.BasicMeasure →
Array Lean.Elab.WF.GuessLex.BasicMeasure →
Lean.Elab.WF.GuessLex.RecCallWithContext →
IO.Ref (Array (Array (Option Lean.Elab.WF.GuessLex.GuessLexRel))) → Lean.Elab.WF.GuessLex.RecCallCache | null | true |
tangentSpaceCast._proof_2 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (x y : M), Function.RightInverse (fun v... | null | false |
Lean.Meta.mkLetValCongr | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Returns `let_val_congr b h` | true |
CategoryTheory.Lax.OplaxTrans.LaxFunctor.bicategory._proof_10 | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_6) [inst_1 : CategoryTheory.Bicategory C]
{a b c : CategoryTheory.LaxFunctor B C} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.Lax.OplaxTrans.whiskerRight (CategoryTheory.CategoryStruct.id f) g =
CategoryTheory.CategoryStruct.id (CategoryTheory.Catego... | null | false |
Set.surjOn_of_subsingleton | Mathlib.Data.Set.Function | ∀ {α : Type u_1} [Subsingleton α] (f : α → α) (s : Set α), Set.SurjOn f s s | null | true |
not_forall_of_exists_not | Init.PropLemmas | ∀ {α : Sort u_1} {p : α → Prop}, (∃ x, ¬p x) → ¬∀ (x : α), p x | null | true |
IntermediateField.essFiniteType_iff | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {K : IntermediateField F E},
Algebra.EssFiniteType F ↥K ↔ K.FG | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.instSubsingletonUniformOnFun._proof_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_2} {β : Type u_1} {𝔖 : Set (Set α)} [Subsingleton β], Subsingleton (UniformOnFun α β 𝔖) | null | false |
Nat.bitIndices_two_pow_mul | Mathlib.Data.Nat.BitIndices | ∀ (k n : ℕ), (2 ^ k * n).bitIndices = List.map (fun x => x + k) n.bitIndices | null | true |
birkhoffSum_one' | Mathlib.Dynamics.BirkhoffSum.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (f : α → α) (g : α → M), birkhoffSum f g 1 = g | **Alias** of `birkhoffSum_one`. | true |
Lean.ExtraModUse.casesOn | Lean.ExtraModUses | {motive : Lean.ExtraModUse → Sort u} →
(t : Lean.ExtraModUse) →
((module : Lean.Name) →
(isExported isMeta : Bool) → motive { module := module, isExported := isExported, isMeta := isMeta }) →
motive t | null | false |
Bicategory.Opposite.Hom2.unop2 | Mathlib.CategoryTheory.Bicategory.Opposites | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → {a b : Bᵒᵖ} → {f g : a ⟶ b} → Bicategory.Opposite.Hom2 f g → (f.unop ⟶ g.unop) | `Bᵒᵖ` preserves the direction of all 2-morphisms in `B` | true |
Std.TreeMap.Raw.compare_getKey_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} (h' : k ∈ t), cmp (t.getKey k h') k = Ordering.eq | null | true |
MeasureTheory.SimpleFunc.approxOn | Mathlib.MeasureTheory.Function.SimpleFuncDense | {α : Type u_1} →
{β : Type u_2} →
[inst : MeasurableSpace α] →
[inst_1 : PseudoEMetricSpace α] →
[OpensMeasurableSpace α] →
[inst_3 : MeasurableSpace β] →
(f : β → α) →
Measurable f →
(s : Set α) →
(y₀ : α) → y₀ ∈ s → [Topological... | Approximate a measurable function by a sequence of simple functions `F n` such that
`F n x ∈ s`. | true |
_private.Mathlib.SetTheory.Cardinal.NatCard.0.Finite.card_eq_zero_iff._simp_1_1 | Mathlib.SetTheory.Cardinal.NatCard | ∀ {α : Type u_1} [inst : Fintype α], (Fintype.card α = 0) = IsEmpty α | null | false |
AddCon.comapQuotientEquivOfSurj_symm_mk' | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (c : AddCon M) (f : N ≃+ M) (x : N),
(c.comapQuotientEquivOfSurj ↑f ⋯).symm ⟦f x⟧ = ↑x | This version infers the surjectivity of the function from a
MulEquiv function | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.getVert_sub_one_ne_getVert_add_one._proof_1_6 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} {i : ℕ} {p : G.Walk u u}, ¬i ≥ p.length - 1 → i + 1 ≤ p.length - 1 | null | false |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.isNilpotent_iff._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M],
LieModule.IsNilpotent L M = ∃ k, LieModule.lowerCentralSeries ℤ L M k = ⊥ | null | false |
List.isGE_compare_nil_right | Init.Data.Ord.Basic | ∀ {α : Type u_1} [inst : Ord α] {xs : List α}, (compare xs []).isGE = true | null | true |
IsOpen.isEverywherePos | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α}
[μ.IsOpenPosMeasure], IsOpen s → μ.IsEverywherePos s | An open set is everywhere positive for a measure which is positive on open sets. | true |
CategoryTheory.CatEnrichedOrdinary.instQuiverHom | Mathlib.CategoryTheory.Bicategory.CatEnriched | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] →
{X Y : CategoryTheory.CatEnrichedOrdinary C} → Quiver (X ⟶ Y) | null | true |
ftaylorSeriesWithin_fun_zero | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : 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],
(ftaylorSeriesWithin 𝕜 fun x => 0) = 0 | null | true |
Finset.sum_boole_mul | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonAssocSemiring R] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → R) (i : ι),
∑ j ∈ s, (if i = j then 1 else 0) * f j = if i ∈ s then f i else 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.