name stringlengths 2 203 | full_string stringlengths 18 12.4k |
|---|---|
ProbabilityTheory.Kernel.disintegrate | theorem ProbabilityTheory.Kernel.disintegrate.{u_1, u_2, u_3} {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mΩ : MeasurableSpace Ω} (κ : ProbabilityTheory.Kernel α (Prod β Ω)) (κCond : ProbabilityTheory.Kernel (Prod α β) Ω) [κ.IsCondKernel κCond] : Eq (κ.fst.compProd κC... |
nhds_nhdsAdjoint | theorem nhds_nhdsAdjoint.{u} {α : Type u} [DecidableEq α] (a : α) (f : Filter α) : Eq nhds (Function.update Filter.instPure.pure a (Filter.instSup.max (Filter.instPure.pure a) f)) |
CategoryTheory.Limits.HasFiniteBiproducts.rec | def CategoryTheory.Limits.HasFiniteBiproducts.rec.{u, uC', uC} {C : Type uC} [CategoryTheory.Category C] [CategoryTheory.Limits.HasZeroMorphisms C] {motive : CategoryTheory.Limits.HasFiniteBiproducts C → Sort u} (mk : (out : ∀ (n : Nat), CategoryTheory.Limits.HasBiproductsOfShape (Fin n) C) → motive ⋯) (t : CategoryThe... |
ContinuousAt.comp₂ | theorem ContinuousAt.comp₂.{u, v, u_1, u_2} {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] [TopologicalSpace W] {f : Prod Y Z → W} {g : X → Y} {h : X → Z} {x : X} (hf : ContinuousAt f { fst := g x, snd := h x }) (hg : ContinuousAt g x) (hh : Contin... |
ProbabilityTheory.mgf_congr_identDistrib | theorem ProbabilityTheory.mgf_congr_identDistrib.{u_1, u_3} {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → Real} {μ : MeasureTheory.Measure Ω} {Ω' : Type u_3} {mΩ' : MeasurableSpace Ω'} {μ' : MeasureTheory.Measure Ω'} {Y : Ω' → Real} (h : ProbabilityTheory.IdentDistrib X Y μ μ') : Eq (ProbabilityTheory.mgf X μ) (Proba... |
Nat.digitChar_ne | /-- Auxiliary theorem for `Nat.reduceDigitCharEq` simproc. -/
theorem Nat.digitChar_ne {n : Nat} (c : Char) (h : Eq (((((((((((((((((bne c '0').and (bne c '1')).and (bne c '2')).and (bne c '3')).and (bne c '4')).and (bne c '5')).and (bne c '6')).and (bne c '7')).and (bne c '8')).and (bne c '9')).and (bne c 'a')).and (b... |
Polynomial.splits_of_degree_le_one_of_monic | theorem Polynomial.splits_of_degree_le_one_of_monic.{u_1} {R : Type u_1} [Semiring R] {f : Polynomial R} (hf : WithBot.instPreorder.le f.degree 1) (h : f.Monic) : f.Splits |
Cardinal.cantorFunction | /-- `cantorFunction c (f : ℕ → Bool)` is `Σ n, f n * c ^ n`, where `true` is interpreted as `1` and
`false` is interpreted as `0`. It is implemented using `cantorFunctionAux`. -/
def Cardinal.cantorFunction (c : Real) (f : Nat → Bool) : Real |
continuous_ofMul | theorem continuous_ofMul.{u} {X : Type u} [TopologicalSpace X] : Continuous (EquivLike.toFunLike.coe Additive.ofMul) |
Submodule.mem_ideal_smul_span_iff_exists_sum | /-- 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`. -/
theorem Submodule.mem_ideal_smul_span_iff_exists_sum.{u, v, u_4} {R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] (I : Ideal R) [I.IsTwoSided] {ι : ... |
Asymptotics.isBigO_of_le' | theorem Asymptotics.isBigO_of_le'.{u_1, u_3, u_4} {α : Type u_1} {E : Type u_3} {F : Type u_4} [Norm E] [Norm F] {c : Real} {f : α → E} {g : α → F} (l : Filter α) (hfg : ∀ (x : α), Real.instLE.le (inst✝.norm (f x)) (instHMul.hMul c (inst✝¹.norm (g x)))) : Asymptotics.IsBigO l f g |
Matroid.loopless_iff_forall_isNonloop | theorem Matroid.loopless_iff_forall_isNonloop.{u_1} {α : Type u_1} {M : Matroid α} : Iff M.Loopless (∀ (e : α), Set.instMembership.mem M.E e → M.IsNonloop e) |
CategoryTheory.Functor.IsStronglyCocartesian.of_comp | /-- Given two commutative squares
```
a --φ--> b --ψ--> c
| | |
v v v
R --f--> S --g--> T
```
such that `φ ≫ ψ` and `φ` are strongly co-Cartesian, then so is `ψ`. -/
theorem CategoryTheory.Functor.IsStronglyCocartesian.of_comp.{v₁, v₂, u₁, u₂} {𝒮 : Type u₁} {𝒳 : Type u₂} [CategoryTheory.Ca... |
CategoryTheory.ShortComplex.exact_iff_exact_up_to_refinements | theorem CategoryTheory.ShortComplex.exact_iff_exact_up_to_refinements.{v_1, u_1} {C : Type u_1} [CategoryTheory.Category C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C) : Iff S.Exact (∀ ⦃A : C⦄ (x₂ : inst✝.Hom A S.X₂), Eq (inst✝.comp x₂ S.g) 0 → Exists fun A' => Exists fun π => Exists fun x => Exists ... |
Nat.zeckendorf.eq_def | theorem Nat.zeckendorf.eq_def (x✝ : Nat) : Eq x✝.zeckendorf (Nat.zeckendorf.match_1 (fun x => List Nat) x✝ (fun _ => List.nil) fun m n h => List.cons m.greatestFib (instHSub.hSub m (Nat.fib m.greatestFib)).zeckendorf) |
Algebra.ofId_apply | theorem Algebra.ofId_apply.{u, v} {R : Type u} (A : Type v) [CommSemiring R] [Semiring A] [Algebra R A] (r : R) : Eq (AlgHom.funLike.coe (Algebra.ofId R A) r) (RingHom.instFunLike.coe (inst✝.algebraMap R A) r) |
transGen_covBy_of_lt | theorem transGen_covBy_of_lt.{u_2} {α : Type u_2} [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : inst✝.lt x y) : Relation.TransGen (fun x1 x2 => CovBy x1 x2) x y |
AlgebraicGeometry.Scheme.Modules.hom_ext | theorem AlgebraicGeometry.Scheme.Modules.hom_ext.{u} {X : AlgebraicGeometry.Scheme} {M N : X.Modules} (f g : AlgebraicGeometry.Scheme.Modules.instCategory.Hom M N) (H : ∀ (U : X.Opens), Eq (AlgebraicGeometry.Scheme.Modules.Hom.app f U) (AlgebraicGeometry.Scheme.Modules.Hom.app g U)) : Eq f g |
NumberField.IsCMField.realUnits | /-- The subgroup of `(𝓞 K)ˣ` generated by the units of `K⁺`. These units are exactly the units fixed
by the complex conjugation, see `IsCMField.unitsComplexConj_eq_self_iff`.
-/
def NumberField.IsCMField.realUnits.{u_1} (K : Type u_1) [Field K] : Subgroup (Units (NumberField.RingOfIntegers K)) |
Encodable.skolem | /-- A constructive version of `Classical.skolem` for `Encodable` types. -/
theorem Encodable.skolem.{u_1, u_2} {α : Type u_1} {β : α → Type u_2} {P : (x : α) → β x → Prop} [(a : α) → Encodable (β a)] [(x : α) → (y : β x) → Decidable (P x y)] : Iff (∀ (x : α), Exists fun y => P x y) (Exists fun f => ∀ (x : α), P x (f x)... |
FirstOrder.Language.Relations.isUniversal_transitive | theorem FirstOrder.Language.Relations.isUniversal_transitive.{u, v} {L : FirstOrder.Language} (r : L.Relations 2) : FirstOrder.Language.BoundedFormula.IsUniversal r.transitive |
IsAddKleinFour.eq_finset_univ | theorem IsAddKleinFour.eq_finset_univ.{u_1} {G : Type u_1} [AddGroup G] [IsAddKleinFour G] [Fintype G] [DecidableEq G] {x y : G} (hx : Ne x 0) (hy : Ne y 0) (hxy : Ne x y) : Eq (Finset.instInsert.insert (instHAdd.hAdd x y) (Finset.instInsert.insert x (Finset.instInsert.insert y (Finset.instSingleton.singleton 0)))) Fin... |
PolynomialLaw.smul_def_apply | theorem PolynomialLaw.smul_def_apply.{u, u_1, u_2} {R : Type u} [CommSemiring R] {M : Type u_1} [AddCommMonoid M] [Module R M] {N : Type u_2} [AddCommMonoid N] [Module R N] (r : R) (f : PolynomialLaw R M N) (S : Type u) [CommSemiring S] [Algebra R S] (m : TensorProduct R S M) : Eq ((instHSMul.hSMul r f).toFun' S m) (in... |
DirectSum.decompose_symm_mul | theorem DirectSum.decompose_symm_mul.{u_1, u_3, u_4} {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [DecidableEq ι] [AddMonoid ι] [Semiring A] [SetLike σ A] [AddSubmonoidClass σ A] (𝒜 : ι → σ) [GradedRing 𝒜] (x y : DirectSum ι fun i => Subtype fun x => SetLike.instMembership.mem (𝒜 i) x) : Eq (EquivLike.toFunLike.coe ... |
OfScientific.ctorIdx | def OfScientific.ctorIdx.{u} {α : Type u} : OfScientific α → Nat |
Order.Ideal.PrimePair.mk.sizeOf_spec | theorem Order.Ideal.PrimePair.mk.sizeOf_spec.{u_2} {P : Type u_2} [Preorder P] [SizeOf P] (I : Order.Ideal P) (F : Order.PFilter P) (isCompl_I_F : IsCompl (Order.Ideal.instSetLike.coe I) (Order.PFilter.instSetLike.coe F)) : Eq ((Order.Ideal.PrimePair._sizeOf_inst P).sizeOf { I := I, F := F, isCompl_I_F := isCompl_I_F }... |
SimpleGraph.boxProd | /-- Box product of simple graphs. It relates `(a₁, b)` and `(a₂, b)` if `G` relates `a₁` and `a₂`,
and `(a, b₁)` and `(a, b₂)` if `H` relates `b₁` and `b₂`. -/
def SimpleGraph.boxProd.{u_1, u_2} {α : Type u_1} {β : Type u_2} (G : SimpleGraph α) (H : SimpleGraph β) : SimpleGraph (Prod α β) |
CocompactMapClass.toCocompactMap | /-- Turn an element of a type `F` satisfying `CocompactMapClass F α β` into an actual
`CocompactMap`. This is declared as the default coercion from `F` to `CocompactMap α β`. -/
def CocompactMapClass.toCocompactMap.{u_1, u_2, u_3} {F : Type u_1} {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] [F... |
OreLocalization.numeratorRingHom | /-- The ring homomorphism from `R` to `R[S⁻¹]`, mapping `r : R` to the fraction `r /ₒ 1`. -/
def OreLocalization.numeratorRingHom.{u_1} {R : Type u_1} [Semiring R] {S : Submonoid R} [OreLocalization.OreSet S] : RingHom R (OreLocalization S R) |
AddSubgroup.addSubgroupOf_eq_top | theorem AddSubgroup.addSubgroupOf_eq_top.{u_1} {G : Type u_1} [AddGroup G] {H K : AddSubgroup G} : Iff (Eq (H.addSubgroupOf K) AddSubgroup.instTop.top) (AddSubgroup.instPartialOrder.le K H) |
SSet.Nonsingular.recOn | def SSet.Nonsingular.recOn.{u_1, u} {X : SSet} {motive : X.Nonsingular → Sort u_1} (t : X.Nonsingular) (mk : (mono : ∀ {n : Nat} (x : (X.nonDegenerate n).Elem), CategoryTheory.Mono (EquivLike.toFunLike.coe SSet.yonedaEquiv.symm x.val)) → motive ⋯) : motive t |
OrderedFinpartition.length_le | theorem OrderedFinpartition.length_le {n : Nat} (c : OrderedFinpartition n) : instLENat.le c.length n |
minpoly.subsingleton | theorem minpoly.subsingleton.{u_1, u_2} (A : Type u_1) {B : Type u_2} [CommRing A] [Ring B] [Algebra A B] (x : B) [Subsingleton B] : Eq (minpoly A x) 1 |
GroupSeminorm.casesOn | def GroupSeminorm.casesOn.{u, u_6} {G : Type u_6} [Group G] {motive : GroupSeminorm G → Sort u} (t : GroupSeminorm G) (mk : (toFun : G → Real) → (map_one' : Eq (toFun 1) 0) → (mul_le' : ∀ (x y : G), Real.instLE.le (toFun (instHMul.hMul x y)) (instHAdd.hAdd (toFun x) (toFun y))) → (inv' : ∀ (x : G), Eq (toFun (DivisionM... |
CategoryTheory.MorphismProperty.Comma.id | /-- The identity morphism of an object in `P.Comma L R Q W`. -/
def CategoryTheory.MorphismProperty.Comma.id.{v_1, u_1, v_2, u_2, v_3, u_3} {A : Type u_1} [CategoryTheory.Category A] {B : Type u_2} [CategoryTheory.Category B] {T : Type u_3} [CategoryTheory.Category T] {L : CategoryTheory.Functor A T} {R : CategoryTheor... |
CategoryTheory.ShortComplex.Splitting.isSplitMono_f | theorem CategoryTheory.ShortComplex.Splitting.isSplitMono_f.{v_1, u_1} {C : Type u_1} [CategoryTheory.Category C] [CategoryTheory.Preadditive C] {S : CategoryTheory.ShortComplex C} (s : S.Splitting) : CategoryTheory.IsSplitMono S.f |
InnerProductGeometry.angle_add_eq_arccos_of_inner_eq_zero | /-- An angle in a right-angled triangle expressed using `arccos`. -/
theorem InnerProductGeometry.angle_add_eq_arccos_of_inner_eq_zero.{u_1} {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace Real V] {x y : V} (h : Eq (inst✝.inner Real x y) 0) : Eq (InnerProductGeometry.angle x (instHAdd.hAdd x y)) (Real.arccos (... |
CategoryTheory.associator_hom_apply_1 | theorem CategoryTheory.associator_hom_apply_1.{u} {X Y Z : Type u} {x : (fun X => X) (CategoryTheory.typesCartesianMonoidalCategory.tensorObj (CategoryTheory.typesCartesianMonoidalCategory.tensorObj X Y) Z)} : Eq (TypeCat.instFunLikeFun.coe (instConcreteCategoryTypeFun.hom (CategoryTheory.typesCartesianMonoidalCategory... |
Std.Time.Second.instTransOrdOffset | theorem Std.Time.Second.instTransOrdOffset : Std.TransOrd Std.Time.Second.Offset |
SSet.StrictSegal.spineToDiagonal | /-- In the presence of the strict Segal condition, a path of length `n` can be
"composed" by taking the diagonal edge of the resulting `n`-simplex. -/
def SSet.StrictSegal.spineToDiagonal.{u} {X : SSet} (sx : X.StrictSegal) {n : Nat} (f : X.Path n) : X.obj { unop := { len := 1 } } |
LucasLehmer.X.fst_intCast | theorem LucasLehmer.X.fst_intCast {q : Nat} (n : Int) : Eq n.cast.fst n.cast |
CategoryTheory.MorphismProperty.RightFraction.map_hom_ofInv_id_assoc | theorem CategoryTheory.MorphismProperty.RightFraction.map_hom_ofInv_id_assoc.{v_1, u_1, v_2, u_2} {C : Type u_1} {D : Type u_2} [CategoryTheory.Category C] [CategoryTheory.Category D] (W : CategoryTheory.MorphismProperty C) {X Y : C} (s : inst✝.Hom Y X) (hs : W s) (L : CategoryTheory.Functor C D) (hL : W.IsInvertedBy L... |
IO.Error.hardwareFault.noConfusion | def IO.Error.hardwareFault.noConfusion.{u} {P : Sort u} {osCode : UInt32} {details : String} {osCode' : UInt32} {details' : String} (eq : Eq (IO.Error.hardwareFault osCode details) (IO.Error.hardwareFault osCode' details')) (k : Eq osCode osCode' → Eq details details' → P) : P |
ZMod.unitsMap | /-- `unitsMap` is a group homomorphism that maps units of `ZMod m` to units of `ZMod n` when `n`
divides `m`. -/
def ZMod.unitsMap {n m : Nat} (hm : Nat.instDvd.dvd n m) : MonoidHom (Units (ZMod m)) (Units (ZMod n)) |
LinearPMap.ext | theorem LinearPMap.ext.{u_1, u_2, u_4, u_5} {R : Type u_1} {S : Type u_2} [Ring R] [Ring S] {σ : RingHom R S} {E : Type u_4} [AddCommGroup E] [Module R E] {F : Type u_5} [AddCommGroup F] [Module S F] {f g : LinearPMap σ E F} (h : Eq f.domain g.domain) (h' : ∀ ⦃x : E⦄ ⦃hf : SetLike.instMembership.mem f.domain x⦄ ⦃hg : S... |
PosPart.recOn | def PosPart.recOn.{u, u_1} {α : Type u_1} {motive : PosPart α → Sort u} (t : PosPart α) (mk : (posPart : α → α) → motive { posPart := posPart }) : motive t |
MeasureTheory.MeasuredSets.dist_def | theorem MeasureTheory.MeasuredSets.dist_def.{u_1} {α : Type u_1} [mα : MeasurableSpace α] {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] (s t : MeasureTheory.MeasuredSets μ) : Eq (MeasureTheory.instPseudoMetricSpaceMeasuredSetsOfIsFiniteMeasure.dist s t) (μ.real (symmDiff (MeasureTheory.instSetLikeMeas... |
GradedRingHom.mk.noConfusion | def GradedRingHom.mk.noConfusion.{u, u_1, u_2, u_3, u_6, u_7} {ι : Type u_1} {A : Type u_2} {B : Type u_3} {σ : Type u_6} {τ : Type u_7} {inst✝ : Semiring A} {inst✝¹ : Semiring B} {inst✝² : SetLike σ A} {inst✝³ : SetLike τ B} {𝒜 : ι → σ} {ℬ : ι → τ} {P : Sort u} {toRingHom : RingHom A B} {map_mem : ∀ {i : ι} {x : A}, ... |
Std.ExtHashMap.getKey?_union_of_not_mem_left | theorem Std.ExtHashMap.getKey?_union_of_not_mem_left.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [EquivBEq α] [LawfulHashable α] {k : α} (not_mem : Not (Std.ExtHashMap.instMembershipOfEquivBEqOfLawfulHashable.mem m₁ k)) : Eq ((Std.ExtHashMap.instUnionOfEquivBEqOfLawfulH... |
NFA.evalFrom_iUnion | theorem NFA.evalFrom_iUnion.{u, v, u_1} {α : Type u} {σ : Type v} (M : NFA α σ) {ι : Sort u_1} (s : ι → Set σ) (x : List α) : Eq (M.evalFrom (Set.iUnion fun i => s i) x) (Set.iUnion fun i => M.evalFrom (s i) x) |
Int.prime_ofNat_iff | theorem Int.prime_ofNat_iff {n : Nat} : Iff (Prime (instOfNat.ofNat n)) (Nat.Prime ((instOfNatNat n).ofNat n)) |
CategoryTheory.Localization.SmallHom.equiv_chgUniv | theorem CategoryTheory.Localization.SmallHom.equiv_chgUniv.{w'', w, v₁, v₂, u₁, u₂} {C : Type u₁} [CategoryTheory.Category C] {W : CategoryTheory.MorphismProperty C} {D : Type u₂} [CategoryTheory.Category D] (L : CategoryTheory.Functor C D) [L.IsLocalization W] {X Y : C} [CategoryTheory.Localization.HasSmallLocalizedHo... |
hasDerivAtFilter_finCons' | /-- A variant of `hasDerivAtFilter_finCons` where the derivative variables are free on the RHS
instead. -/
theorem hasDerivAtFilter_finCons'.{u, u_1} {𝕜 : Type u} [NontriviallyNormedField 𝕜] {n : Nat} {F' : Fin n.succ → Type u_1} [(i : Fin n.succ) → NormedAddCommGroup (F' i)] [(i : Fin n.succ) → NormedSpace 𝕜 (F' i)... |
Module.End.ringEquivEndFinsupp_apply_apply_support | theorem Module.End.ringEquivEndFinsupp_apply_apply_support.{u_4, u_5, u_6} {ι : Type u_4} {R : Type u_5} {M : Type u_6} [Semiring R] [AddCommMonoid M] [Module R M] (i : ι) (a✝ : Module.End (Module.End R M) M) (a : Finsupp ι M) : Eq (LinearMap.instFunLike.coe (EquivLike.toFunLike.coe (Module.End.ringEquivEndFinsupp i) a... |
AlgebraicGeometry.instGeometricallyIntegralMorphismRestrict | theorem AlgebraicGeometry.instGeometricallyIntegralMorphismRestrict.{u_1} {X S : AlgebraicGeometry.Scheme} (f : AlgebraicGeometry.Scheme.instCategory.Hom X S) (V : S.Opens) [AlgebraicGeometry.GeometricallyIntegral f] : AlgebraicGeometry.GeometricallyIntegral (AlgebraicGeometry.morphismRestrict f V) |
right_ne_zero_of_mul | theorem right_ne_zero_of_mul.{u_1} {M₀ : Type u_1} [MulZeroClass M₀] {a b : M₀} : Ne (instHMul.hMul a b) 0 → Ne b 0 |
BitVec.bit_not_eq_not | theorem BitVec.bit_not_eq_not {w : Nat} (x : BitVec w) : Eq (BitVec.iunfoldr (fun i c => { fst := c, snd := (Fin.instGetElemFinVal.getElem x i ⋯).not }) Unit.unit).snd (BitVec.instComplement.complement x) |
BoxIntegral.unitPartition.disjoint | theorem BoxIntegral.unitPartition.disjoint.{u_1} {ι : Type u_1} {n : Nat} [NeZero n] {ν ν' : ι → Int} : Iff (Ne ν ν') (Disjoint (BoxIntegral.unitPartition.box n ν).toSet (BoxIntegral.unitPartition.box n ν').toSet) |
Fin.snoc_castAdd | theorem Fin.snoc_castAdd.{u_2} {m n : Nat} {α : Fin (instHAdd.hAdd (instHAdd.hAdd n m) 1) → Sort u_2} (f : (i : Fin (instHAdd.hAdd n m)) → α i.castSucc) (a : α (Fin.last (instHAdd.hAdd n m))) (i : Fin n) : Eq (Fin.snoc f a (Fin.castAdd (instHAdd.hAdd m 1) i)) (f (Fin.castAdd m i)) |
LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right | /-- Composition with a linear isometry on the right preserves the norm of the iterated derivative
within a set. -/
theorem LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right.{u_1, u_2, u_3, u_4} {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E] [Norme... |
Real.summable_nat_pow_inv | /-- Test for convergence of the `p`-series: the real-valued series `∑' n : ℕ, (n ^ p)⁻¹` converges
if and only if `1 < p`. -/
theorem Real.summable_nat_pow_inv {p : Nat} : Iff (Summable fun n => Real.instInv.inv (instHPow.hPow n.cast p)) (instLTNat.lt 1 p) |
Nat.WithBot.add_one_le_of_lt | theorem Nat.WithBot.add_one_le_of_lt {n m : WithBot Nat} (h : WithBot.instPreorder.lt n m) : WithBot.instPreorder.le (instHAdd.hAdd n 1) m |
Int.Linear.eq_def_norm | theorem Int.Linear.eq_def_norm (ctx : Int.Linear.Context) (x : Int.Linear.Var) (xPoly xPoly' p : Int.Linear.Poly) : Eq (Int.Linear.eq_def_cert x xPoly' p) Bool.true → Eq (Int.Linear.Var.denote ctx x) (Int.Linear.Poly.denote' ctx xPoly) → Eq (Int.Linear.Poly.denote' ctx xPoly) (Int.Linear.Poly.denote' ctx xPoly') → Eq (... |
ContDiffAt.dist | theorem ContDiffAt.dist.{u_1, u_2, u_4} (𝕜 : Type u_1) {E : Type u_2} [RCLike 𝕜] [NormedAddCommGroup E] [InnerProductSpace 𝕜 E] [NormedSpace Real E] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace Real G] {f g : G → E} {x : G} {n : WithTop ENat} (hf : ContDiffAt Real n f x) (hg : ContDiffAt Real n g x) (hne : Ne ... |
ModuleCat.Derivation.d | /-- The underlying map `B → M` of a derivation `M.Derivation f` when `M : ModuleCat B`
and `f : A ⟶ B` is a morphism in `CommRingCat`. -/
def ModuleCat.Derivation.d.{v, u} {A B : CommRingCat} {M : ModuleCat B.carrier} {f : CommRingCat.instCategory.Hom A B} (D : M.Derivation f) (b : B.carrier) : M.carrier |
SemimoduleCat.MonoidalCategory.tensor_ext₃ | /-- Extensionality lemma for morphisms from a module of the form `M₁ ⊗ (M₂ ⊗ M₃)`. -/
theorem SemimoduleCat.MonoidalCategory.tensor_ext₃.{u} {R : Type u} [CommSemiring R] {M₁ M₂ M₃ M₄ : SemimoduleCat R} {f g : (SemimoduleCat.moduleCategory R).Hom (SemimoduleCat.MonoidalCategory.instMonoidalCategoryStruct.tensorObj M₁ (... |
AlgebraicGeometry.instIsZariskiLocalAtSourceTopologicallyIsOpenMap | theorem AlgebraicGeometry.instIsZariskiLocalAtSourceTopologicallyIsOpenMap.{u_1} : AlgebraicGeometry.IsZariskiLocalAtSource (AlgebraicGeometry.topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => IsOpenMap) |
Monoid.CoprodI.Word.mk | def Monoid.CoprodI.Word.mk.{u_1, u_2} {ι : Type u_1} {M : ι → Type u_2} [(i : ι) → Monoid (M i)] (toList : List (Sigma fun i => M i)) (ne_one : ∀ (l : Sigma fun i => M i), List.instMembership.mem toList l → Ne l.snd 1) (chain_ne : List.IsChain (fun l l' => Ne l.fst l'.fst) toList) : Monoid.CoprodI.Word M |
CategoryTheory.IsPreconnected.of_constant_of_preserves_morphisms | /-- `J` is connected if: given any function `F : J → α` which is constant for any
`j₁, j₂` for which there is a morphism `j₁ ⟶ j₂`, then `F` is constant.
This can be thought of as a local-to-global property.
The converse of `constant_of_preserves_morphisms`.
-/
theorem CategoryTheory.IsPreconnected.of_constant_of_pre... |
MvPolynomial.constantCoeff_comp_C | theorem MvPolynomial.constantCoeff_comp_C.{u, u_1} (R : Type u) (σ : Type u_1) [CommSemiring R] : Eq (MvPolynomial.constantCoeff.comp MvPolynomial.C) (RingHom.id R) |
ContDiffBump.normed_le_div_measure_closedBall_rOut | theorem ContDiffBump.normed_le_div_measure_closedBall_rOut.{u_1} {E : Type u_1} [NormedAddCommGroup E] [NormedSpace Real E] [HasContDiffBump E] [MeasurableSpace E] {c : E} (f : ContDiffBump c) (μ : MeasureTheory.Measure E) [BorelSpace E] [FiniteDimensional Real E] [MeasureTheory.IsLocallyFiniteMeasure μ] [μ.IsAddHaarMe... |
closedPoints | /-- The set of closed points. -/
def closedPoints.{u_1} (X : Type u_1) [TopologicalSpace X] : Set X |
CategoryTheory.MonObj.one_braiding | theorem CategoryTheory.MonObj.one_braiding.{v₁, u₁} {C : Type u₁} [CategoryTheory.Category C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.BraidedCategory C] (X Y : C) [CategoryTheory.MonObj X] [CategoryTheory.MonObj Y] : Eq (inst✝.comp CategoryTheory.MonObj.tensorObj.instTensorObj.one (inst✝¹.braiding X Y).hom)... |
CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_snd_assoc | theorem CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_snd_assoc.{v_1, u_1} {C : Type u_1} [CategoryTheory.Category C] [CategoryTheory.Limits.HasPullbacks C] {X Y Z : C} (f : inst✝.Hom X Z) (g : inst✝.Hom Y Z) {Z✝ : C} (h : inst✝.Hom Y Z✝) : Eq (inst✝.comp (CategoryTheory.Limits.diagonalObjPullbackFstIso f g).... |
AddSubgroup.addOrderOf_mk | theorem AddSubgroup.addOrderOf_mk.{u_1} {G : Type u_1} [AddGroup G] {H : AddSubgroup G} (a : G) (ha : SetLike.instMembership.mem H a) : Eq (addOrderOf ⟨a, ha⟩) (addOrderOf a) |
TopModuleCat.coinduced | /-- The coinduced topology on `M` from a family of continuous linear maps into `M`, which is the
finest topology that makes it into a topological module and makes every map continuous. -/
def TopModuleCat.coinduced.{u, u_1, u_2} {R : Type u} [Ring R] [TopologicalSpace R] {M : ModuleCat R} {I : Type u_1} {X : I → TopMod... |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.single.congr_simp | theorem CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.single.congr_simp.{w} {J : Type w} [CategoryTheory.SmallCategory J] {κ : Cardinal} [Fact κ.IsRegular] (j j✝ : J) (e_j : Eq j j✝) : Eq (CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.single j) (CategoryTheory.IsCardinalFiltere... |
LaurentPolynomial.counit_C_mul_T | theorem LaurentPolynomial.counit_C_mul_T.{u_1, u_2} {R : Type u_1} {A : Type u_2} [CommSemiring R] [Semiring A] [Module R A] [Coalgebra R A] (a : A) (n : Int) : Eq (LinearMap.instFunLike.coe (LaurentPolynomial.instCoalgebra R A).counit (instHMul.hMul (RingHom.instFunLike.coe LaurentPolynomial.C a) (LaurentPolynomial.T ... |
CategoryTheory.HasSeparator.hasDetector | theorem CategoryTheory.HasSeparator.hasDetector.{v₁, u₁} {C : Type u₁} [CategoryTheory.Category C] [CategoryTheory.Balanced C] [CategoryTheory.HasSeparator C] : CategoryTheory.HasDetector C |
Matrix.SpecialLinearGroup.ext | theorem Matrix.SpecialLinearGroup.ext.{u, v} {n : Type u} [DecidableEq n] [Fintype n] {R : Type v} [CommRing R] (A B : Matrix.SpecialLinearGroup n R) : (∀ (i j : n), Eq (A.val i j) (B.val i j)) → Eq A B |
CategoryTheory.ObjectProperty.ColimitOfShape.ofIso | /-- If `X` is a colimit indexed by `J` of objects satisfying a property `P`, then
any object that is isomorphic to `X` also is. -/
def CategoryTheory.ObjectProperty.ColimitOfShape.ofIso.{v', u', v_1, u_1} {C : Type u_1} [CategoryTheory.Category C] {P : CategoryTheory.ObjectProperty C} {J : Type u'} [CategoryTheory.Cate... |
contDiffOn_prod' | theorem contDiffOn_prod'.{uE, u_1, u_4, u_5} {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type uE} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {s : Set E} {n : WithTop ENat} {𝔸' : Type u_4} {ι : Type u_5} [NormedCommRing 𝔸'] [NormedAlgebra 𝕜 𝔸'] {t : Finset ι} {f : ι → E → 𝔸'} (h : ∀ (i : ι), SetLike.instMember... |
Std.DTreeMap.Const.forInUncurried_eq_forIn_toList | theorem Std.DTreeMap.Const.forInUncurried_eq_forIn_toList.{u, v, w, w'} {α : Type u} {cmp : α → α → Ordering} {δ : Type w} {m : Type w → Type w'} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Monad m] [LawfulMonad m] {f : Prod α β → δ → m (ForInStep δ)} {init : δ} : Eq (Std.DTreeMap.Const.forInUncurried f init t)... |
Module.Basis.coord_equivFun_symm | theorem Module.Basis.coord_equivFun_symm.{u_10, u_11, u_12} {ι : Type u_10} {R : Type u_11} {M : Type u_12} [Semiring R] [AddCommMonoid M] [Module R M] [Finite ι] (b : Module.Basis ι R M) (i : ι) (f : ι → R) : Eq (LinearMap.instFunLike.coe (b.coord i) (EquivLike.toFunLike.coe b.equivFun.symm f)) (f i) |
isCompact_closure_singleton | /-- In an R₀ space, the closure of a singleton is a compact set. -/
theorem isCompact_closure_singleton.{u_1} {X : Type u_1} [TopologicalSpace X] [R0Space X] {x : X} : IsCompact (closure (Set.instSingletonSet.singleton x)) |
CategoryTheory.Join.mapWhiskerLeft_id | theorem CategoryTheory.Join.mapWhiskerLeft_id.{v₁, v₂, v₃, v₄, u₁, u₂, u₃, u₄} {C : Type u₁} [CategoryTheory.Category C] {D : Type u₂} [CategoryTheory.Category D] {E : Type u₃} [CategoryTheory.Category E] {E' : Type u₄} [CategoryTheory.Category E'] (H : CategoryTheory.Functor C E) (Fᵣ : CategoryTheory.Functor D E') : E... |
FirstOrder.Language.presburger.realize_natCast | theorem FirstOrder.Language.presburger.realize_natCast.{u_1, u_2} {α : Type u_1} {M : Type u_2} {v : α → M} [AddMonoidWithOne M] {n : Nat} : Eq (FirstOrder.Language.Term.realize v n.cast) n.cast |
IntermediateField.finInsepDegree_top | theorem IntermediateField.finInsepDegree_top.{u, v, w} {F : Type u} (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K] : Eq (Field.finInsepDegree F (Subtype fun x => SetLike.instMembership.mem IntermediateField.instCompleteLattice.top x)) (Field.finIn... |
AffineEquiv.prodCongr_apply | theorem AffineEquiv.prodCongr_apply.{u_1, u_2, u_3, u_4, u_5, u_6, u_7, u_8, u_9} {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {P₃ : Type u_4} {P₄ : Type u_5} {V₁ : Type u_6} {V₂ : Type u_7} {V₃ : Type u_8} {V₄ : Type u_9} [Ring k] [AddCommGroup V₁] [AddCommGroup V₂] [AddCommGroup V₃] [AddCommGroup V₄] [Module k V₁] ... |
GradedAlgHom.comp_toGradedRingHom | theorem GradedAlgHom.comp_toGradedRingHom.{u_1, u_6, u_7, u_8, u_10} {R : Type u_1} {A : Type u_6} {B : Type u_7} {C : Type u_8} {ι : Type u_10} [CommSemiring R] [Semiring A] [Semiring B] [Semiring C] [Algebra R A] [Algebra R B] [Algebra R C] [DecidableEq ι] [AddMonoid ι] {𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B... |
Aesop.Rapp.elim | def Aesop.Rapp.elim : Aesop.Rapp → Aesop.RappData Aesop.Goal Aesop.MVarCluster |
CategoryTheory.Presheaf.tautologicalCocone'_ι_app | theorem CategoryTheory.Presheaf.tautologicalCocone'_ι_app.{w, v₁, u₁} {C : Type u₁} [CategoryTheory.Category C] (P : CategoryTheory.Functor (Opposite C) (Type (max w v₁))) (X : CategoryTheory.CostructuredArrow CategoryTheory.uliftYoneda P) : Eq ((CategoryTheory.Presheaf.tautologicalCocone' P).ι.app X) X.hom |
DistLat.mk.inj | theorem DistLat.mk.inj.{u_1} {carrier : Type u_1} {str : DistribLattice carrier} {carrier✝ : Type u_1} {str✝ : DistribLattice carrier✝} : Eq { carrier := carrier, str := str } { carrier := carrier✝, str := str✝ } → And (Eq carrier carrier✝) (HEq str str✝) |
Subgroup.normalizer_le_normalizer_sup_of_normalizer_le_right | theorem Subgroup.normalizer_le_normalizer_sup_of_normalizer_le_right.{u_2} {G : Type u_2} [Group G] {H K : Subgroup G} (hHnK : Subgroup.instPartialOrder.le (Subgroup.normalizer (Subgroup.instSetLike.coe H)) (Subgroup.normalizer (Subgroup.instSetLike.coe K))) : Subgroup.instPartialOrder.le (Subgroup.normalizer (Subgroup... |
IO.Ref | /-- Mutable reference cells that contain values of type `α`. These cells can read from and mutated in
the `IO` monad.
-/
def IO.Ref (α : Type) : Type |
Int.neg_inj | theorem Int.neg_inj {a b : Int} : Iff (Eq (Int.instNegInt.neg a) (Int.instNegInt.neg b)) (Eq a b) |
ClosedSubmodule.symplComp_inf | theorem ClosedSubmodule.symplComp_inf.{u_1} {H : Type u_1} [NormedAddCommGroup H] [ipc : InnerProductSpace Complex H] [CompleteSpace H] (S T : ClosedSubmodule Real H) : Eq (ClosedSubmodule.instInf.min S T).symplComp (ClosedSubmodule.instMax.max S.symplComp T.symplComp) |
UInt16.shiftLeft_and | theorem UInt16.shiftLeft_and {a b c : UInt16} : Eq (instHShiftLeftOfShiftLeft.hShiftLeft (instHAndOfAndOp.hAnd a b) c) (instHAndOfAndOp.hAnd (instHShiftLeftOfShiftLeft.hShiftLeft a c) (instHShiftLeftOfShiftLeft.hShiftLeft b c)) |
CategoryTheory.sum.inlCompInlCompAssociator_inv_app_down | theorem CategoryTheory.sum.inlCompInlCompAssociator_inv_app_down.{v₁, v₂, v₃, u₁, u₂, u₃} (C : Type u₁) [CategoryTheory.Category C] (D : Type u₂) [CategoryTheory.Category D] (E : Type u₃) [CategoryTheory.Category E] (X : C) : Eq ((CategoryTheory.sum.inlCompInlCompAssociator C D E).inv.app X).down (inst✝.comp ((Category... |
LieSubalgebra.ucs_eq_self_of_isCartanSubalgebra | theorem LieSubalgebra.ucs_eq_self_of_isCartanSubalgebra.{u, v} {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (H : LieSubalgebra R L) [H.IsCartanSubalgebra] (k : Nat) : Eq (LieSubmodule.ucs k H.toLieSubmodule) H.toLieSubmodule |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 81