name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SkewMonoidAlgebra.liftNCAlgHom | Mathlib.Algebra.SkewMonoidAlgebra.Lift | {k : Type u_1} →
{G : Type u_2} →
[inst : CommSemiring k] →
[inst_1 : Monoid G] →
{A : Type u_4} →
{B : Type u_5} →
[inst_2 : Semiring A] →
[inst_3 : Algebra k A] →
[inst_4 : Semiring B] →
[inst_5 : Algebra k B] →
... | `liftNCRingHom` as an `AlgHom`, for when `f` is an `AlgHom` | true |
Real.sin_two_mul | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sin (2 * x) = 2 * Real.sin x * Real.cos x | null | true |
Pointed.coe_of | Mathlib.CategoryTheory.Category.Pointed | ∀ {X : Type u_1} (point : X), (Pointed.of point).X = X | null | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.sup'._simp_1_2 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {p : α ×' β → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | null | false |
CategoryTheory.Limits.instDecidableEqWalkingReflexivePair | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | DecidableEq CategoryTheory.Limits.WalkingReflexivePair | null | true |
NNReal.instLinearOrderedCommGroupWithZero._proof_4 | Mathlib.Data.NNReal.Defs | ∀ (a : NNReal), CommGroupWithZero.zpow 0 a = 1 | null | false |
CategoryTheory.Limits.hasColimit_of_coequalizer_and_coproduct | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor F.obj)]
[CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun f => F.obj f.fst.1)]
[C... | Given the existence of the appropriate (possibly finite) coproducts and coequalizers,
we know a colimit of `F` exists.
(This assumes the existence of all coequalizers, which is technically stronger than needed.)
| true |
AddGroupConeClass | Mathlib.Algebra.Order.Group.Cone | (S : Type u_1) → (G : outParam (Type u_2)) → [AddCommGroup G] → [SetLike S G] → Prop | `AddGroupConeClass S G` says that `S` is a type of cones in `G`. | true |
_private.Lean.LibrarySuggestions.SineQuaNon.0.Lean.LibrarySuggestions.SineQuaNon.initFn._@.Lean.LibrarySuggestions.SineQuaNon.830398421._hygCtx._hyg.2 | Lean.LibrarySuggestions.SineQuaNon | IO (Lean.SimplePersistentEnvExtension Lean.Name Lean.NameSet) | null | false |
SubMulAction.mem_carrier | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] {p : SubMulAction R M} {x : M}, x ∈ p.carrier ↔ x ∈ ↑p | null | true |
Profinite.NobelingProof.spanCone._proof_4 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} {C : Set (I → Bool)}, TotallyDisconnectedSpace { x // x ∈ C } | null | false |
Lean.Parser.ParserAliasInfo.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAliasInfo → Sort u} →
(t : Lean.Parser.ParserAliasInfo) →
((declName : Lean.Name) →
(stackSz? : Option ℕ) →
(autoGroupArgs : Bool) →
motive { declName := declName, stackSz? := stackSz?, autoGroupArgs := autoGroupArgs }) →
motive t | null | false |
LocallyConstant.congrRightₗ._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] {Z : Type u_3} (R : Type u_4) [inst_1 : Semiring R]
[inst_2 : AddCommMonoid Y] [inst_3 : Module R Y] [inst_4 : AddCommMonoid Z] [inst_5 : Module R Z] (e : Y ≃ₗ[R] Z),
Function.RightInverse (LocallyConstant.congrRight e.toEquiv).invFun (LocallyConstant.cong... | null | false |
List.twoStepInduction._proof_2 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x y : α) (xs : List α), (invImage (fun x => x) sizeOfWFRel).1 xs (x :: y :: xs) | null | false |
isClosed_empty | Mathlib.Topology.Basic | ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed ∅ | null | true |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.exists_lt_of_lt_ciSup.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_2} [inst : ConditionallyCompleteLinearOrder α] {b : α} {f : ι → α}
(motive : (∃ a ∈ Set.range f, b < a) → Prop) (x : ∃ a ∈ Set.range f, b < a),
(∀ (i : ι) (h : b < f i), motive ⋯) → motive x | null | false |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.isValidPercentEncoding._proof_1 | Std.Http.Data.URI.Encoding | ∀ (ba : ByteArray) (i : ℕ), i + 2 < ba.size → ¬i + 1 < ba.size → False | null | false |
MulLECancellable.le_mul_iff_one_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : MulOneClass α] [MulLeftMono α] {a b : α},
MulLECancellable a → (a ≤ a * b ↔ 1 ≤ b) | null | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_1 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α}, (Set.range f ⊆ s) = ∀ (y : ι), f y ∈ s | null | false |
AddChar.zmodAddEquiv._proof_3 | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {n : ℕ} [inst : NeZero n],
Function.Bijective ⇑(AddChar.circleEquivComplex.toAddMonoidHom.comp AddChar.zmodHom.toAddMonoidHom) | null | false |
Nat.add_sub_cancel | Init.Data.Nat.Basic | ∀ (n m : ℕ), n + m - m = n | null | true |
«term_⁻ᵐ» | Mathlib.Algebra.Notation | Lean.TrailingParserDescr | The *negative part* of an element `a`. | true |
Lean.Elab.Term.CollectPatternVars.Context.newArgs | Lean.Elab.PatternVar | Lean.Elab.Term.CollectPatternVars.Context → Array Lean.Term | null | true |
NegMemClass.neg | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_5} → {S : Type u_6} → [inst : Neg G] → [inst_1 : SetLike S G] → [NegMemClass S G] → {H : S} → Neg ↥H | An additive subgroup of an `AddGroup` inherits an inverse. | true |
Lean.Elab.Term.PostponeBehavior.ctorElimType | Lean.Elab.SyntheticMVars | {motive : Lean.Elab.Term.PostponeBehavior → Sort u} → ℕ → Sort (max 1 u) | null | false |
ModuleCat.hom_whiskerLeft | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommRing R] (L : ModuleCat R) {M N : ModuleCat R} (f : M ⟶ N),
ModuleCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.whiskerLeft L f) =
LinearMap.lTensor (↑L) (ModuleCat.Hom.hom f) | null | true |
FirstOrder.Language.Embedding.map_rel | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.Embedding M N) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x) ↔ FirstOrder.Language.Structure.RelMap r x | null | true |
IsLocalization.orderIsoOfMaximal._proof_7 | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (y : R) [inst_2 : Algebra R S]
[inst_3 : IsLocalization.Away y S] [inst_4 : IsJacobsonRing R] (x : { p // p.IsMaximal ∧ y ∉ p }),
⟨Ideal.comap (algebraMap R S) ↑⟨Ideal.map (algebraMap R S) ↑x, ⋯⟩, ⋯⟩ = x | null | false |
AddSubgroup.map._proof_3 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_2} [inst : AddGroup G] {N : Type u_1} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
0 ∈ (AddSubmonoid.map f H.toAddSubmonoid).carrier | null | false |
CategoryTheory.InjectiveResolution.desc.eq_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y)
(I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z),
CategoryTheory.InjectiveResolution.desc f I J =
J.cocomplex.mkHom I.cocomplex (CategoryTheory.InjectiveResolut... | null | true |
ProbabilityTheory.Kernel.IndepSets.union_iff._simp_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α},
ProbabilityTheory.Kernel.IndepSets (s₁ ∪ s₂) s' κ μ =
(ProbabilityTheory.Kernel.IndepSets s₁ s' κ μ ∧ ProbabilityTheory.Kernel.IndepSets ... | null | false |
CategoryTheory.Hopf.instCategory | Mathlib.CategoryTheory.Monoidal.Hopf_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Category.{v₁, max u₁ v₁} (CategoryTheory.Hopf C) | Morphisms of Hopf monoids are just morphisms of the underlying bimonoids.
In fact they automatically intertwine the antipodes, proved below.
| true |
instSliceableSubarrayNat_8 | Init.Data.Slice.Array.Basic | {α : Type u} → Std.Rii.Sliceable (Subarray α) ℕ (Subarray α) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.exists_isPath_forall_isPath_length_le_length.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} (G : SimpleGraph V) (n : ℕ),
let s := {n | ∃ u v p, p.IsPath ∧ p.length = n};
∀ (motive : n ∈ s → Prop) (x : n ∈ s),
(∀ (w w_1 : V) (w_2 : G.Walk w w_1) (hp : w_2.IsPath) (hn : w_2.length = n), motive ⋯) → motive x | null | false |
ISize.toUSize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.toUSize (OfNat.ofNat n) = OfNat.ofNat n | null | true |
CategoryTheory.ShortComplex.FunctorEquivalence.unitIso._proof_10 | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_3) [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.ShortComplex (CategoryTheory.Functor J C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.... | null | false |
UpperSet.instMax._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s t : UpperSet α), IsUpperSet (↑s ∩ ↑t) | null | false |
Aesop.ForwardClusterStateStats.casesOn | Aesop.Stats.Basic | {motive : Aesop.ForwardClusterStateStats → Sort u} →
(t : Aesop.ForwardClusterStateStats) →
((slots : ℕ) →
(instantiationStats : Array Aesop.ForwardInstantiationStats) →
motive { slots := slots, instantiationStats := instantiationStats }) →
motive t | null | false |
HahnSeries.isPWO_support._simp_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R), x.support.IsPWO = True | null | false |
Primcodable.subtype._proof_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop} [inst_1 : DecidablePred p] (n : ℕ),
Encodable.encode ((Encodable.decode n).bind fun a => Option.guard (fun b => decide (p b)) a) =
Encodable.encode ((Encodable.decode n).bind fun x => if h : p x then some ⟨x, h⟩ else none) | null | false |
AlgebraNorm.recOn | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{motive : AlgebraNorm R S → Sort u} →
(t : AlgebraNorm R S) →
((toRingNorm : RingNorm S) →
(smul' : ∀ (a : R) (x : S), toRingNorm.toFun... | null | false |
Equiv.withBotCongr_refl | Mathlib.Order.WithBot | ∀ {α : Type u_1}, (Equiv.refl α).withBotCongr = Equiv.refl (WithBot α) | null | true |
_private.Mathlib.Tactic.ClickSuggestions.Unfold.0.Mathlib.Tactic.ClickSuggestions.filteredUnfolds | Mathlib.Tactic.ClickSuggestions.Unfold | Lean.Expr → Lean.MetaM (Array Lean.Expr) | Return the consecutive unfoldings of `e` that are user friendly. | true |
SeparationQuotient.lift.congr_simp | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {α : Type u_4} [inst : TopologicalSpace X] (f f_1 : X → α) (e_f : f = f_1)
(hf : ∀ (x y : X), Inseparable x y → f x = f y) (a a_1 : SeparationQuotient X),
a = a_1 → SeparationQuotient.lift f hf a = SeparationQuotient.lift f_1 ⋯ a_1 | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.Step.length.match_1_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (motive : (x x_1 : List (α × Bool)) → FreeGroup.Red.Step x x_1 → Prop) (x x_1 : List (α × Bool))
(x_2 : FreeGroup.Red.Step x x_1),
(∀ (L1 L2 : List (α × Bool)) (x : α) (b : Bool), motive (L1 ++ (x, b) :: (x, !b) :: L2) (L1 ++ L2) ⋯) →
motive x x_1 x_2 | null | false |
Similar.index_map | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {ι' : Type u_2} {P₁ : Type u_3} {P₂ : Type u_4} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂],
Similar v₁ v₂ → ∀ (f : ι' → ι), Similar (v₁ ∘ f) (v₂ ∘ f) | Change the index set ι to an index ι' that maps to ι. | true |
ae_restrict_le_codiscreteWithin | Mathlib.MeasureTheory.Topology | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
{μ : MeasureTheory.Measure α} [MeasureTheory.NoAtoms μ] {U : Set α},
MeasurableSet U → MeasureTheory.ae (μ.restrict U) ≤ Filter.codiscreteWithin U | Under reasonable assumptions, sets that are codiscrete within `U` are contained in the "almost
everywhere" filter of co-null sets. | true |
Lean.Meta.Sym.DSimp.dsimpMatch | Lean.Meta.Sym.DSimp.Reduce | Lean.Meta.Sym.DSimp.DSimproc | null | true |
AddMonoidAlgebra.domCongr._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (A : Type u_1) {M : Type u_2} {N : Type u_3} [inst : Semiring A] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(e : M ≃+ N) (x y : AddMonoidAlgebra A M),
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun (x + y) =
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun x + (AddMonoidAlgebra.mapDomainRingEquiv A e).toFu... | null | false |
Finset.neg_smul_finset | Mathlib.Algebra.Ring.Action.Pointwise.Finset | ∀ {R : Type u_1} {G : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup G] [inst_2 : Module R G] [inst_3 : DecidableEq G]
{t : Finset G} {a : R}, -a • t = -(a • t) | null | true |
instNonUnitalCStarAlgebraSubtypePreLpMemAddSubgroupLpTopENNReal._proof_3 | Mathlib.Analysis.CStarAlgebra.lpSpace | ∀ {I : Type u_1} {A : I → Type u_2} [inst : (i : I) → NonUnitalCStarAlgebra (A i)], CStarRing ↥(lp A ⊤) | null | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_19 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → ¬a = x → a ∈ y :: tail | null | false |
FreeRing.castFreeCommRing.eq_1 | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u_1}, FreeRing.castFreeCommRing = ⇑FreeRing.toFreeCommRing | null | true |
Std.Time.Internal.Bounded.LE.toFin._proof_2 | Std.Time.Internal.Bounded | ∀ {lo hi : ℤ} (n : Std.Time.Internal.Bounded.LE lo hi), 0 ≤ lo → 0 ≤ hi + 1 | null | false |
String.Slice.Pos.apply_revSkipWhile_prop._proof_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String.Slice} {pos : s.Pos} {h : pos.revSkipWhile P ≠ s.startPos},
(pos.revSkipWhile P).prev h ≠ s.endPos | null | false |
definition._proof_3._@.Mathlib.RingTheory.ClassGroup.Basic.3062443935._hygCtx._hyg.2 | Mathlib.RingTheory.ClassGroup.Basic | ∀ (R : Type u_2) (K : Type u_1) [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K],
↑{ val := FractionalIdeal.spanSingleton (nonZeroDivisors R) ↑1,
inv := FractionalIdeal.spanSingleton (nonZeroDivisors R) (↑1)⁻¹, val_inv := ⋯, inv_val := ⋯ } =
↑1 | null | false |
NonarchimedeanAddGroup | Mathlib.Topology.Algebra.Nonarchimedean.Basic | (G : Type u_1) → [AddGroup G] → [TopologicalSpace G] → Prop | A topological additive group is nonarchimedean if every neighborhood of 0
contains an open subgroup. | true |
CategoryTheory.MonoidalClosed.uncurry_ihomCurry | Mathlib.CategoryTheory.Monoidal.Closed.InternalCurrying | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (x y z : C)
[inst_2 : CategoryTheory.Closed x] [inst_3 : CategoryTheory.Closed y]
[inst_4 : CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)],
CategoryTheory.MonoidalClosed.uncurry (Cat... | null | true |
MeasurableSpace.mapNatBool | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | (α : Type u_1) → [inst : MeasurableSpace α] → [MeasurableSpace.CountablyGenerated α] → α → ℕ → Bool | A map from a measurable space to the Cantor space `ℕ → Bool` induced by a countable
sequence of sets generating the measurable space. | true |
UniqueFactorizationMonoid.toNormalizedGCDMonoid._proof_8 | Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid | ∀ (α : Type u_1) [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [inst_2 : NormalizationMonoid α]
(a b : α), (Associates.mk a ⊓ Associates.mk b).out ∣ b | null | false |
BitVec.extractLsb_xor | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {y x : BitVec w} {hi lo : ℕ},
BitVec.extractLsb lo hi (x ^^^ y) = BitVec.extractLsb lo hi x ^^^ BitVec.extractLsb lo hi y | null | true |
Ideal.IsMaximal.ne_bot_of_isIntegral_int | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} [inst : CommRing R] [CharZero R] [Algebra.IsIntegral ℤ R] (I : Ideal R) [I.IsMaximal], I ≠ ⊥ | null | true |
HomogeneousLocalization.AtPrime | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} → [inst : CommRing A] → [SetLike σ A] → (ι → σ) → (𝔭 : Ideal A) → [𝔭.IsPrime] → Type (max u_1 u_2) | Localizing a ring homogeneously at a prime ideal. | true |
LinearPMap.sSup_le | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {c : Set (E →ₛₗ.[σ] F)}
(hc : DirectedOn (fun x1 x2 => x1 ≤ x2) c) {g : E →ₛₗ.[σ] F}, (∀ f ∈ c, f ≤ g) → Linea... | null | true |
Mathlib.Linter.TextBased.ErrorFormat.rec | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorFormat → Sort u} →
motive Mathlib.Linter.TextBased.ErrorFormat.humanReadable →
motive Mathlib.Linter.TextBased.ErrorFormat.exceptionsFile →
motive Mathlib.Linter.TextBased.ErrorFormat.github → (t : Mathlib.Linter.TextBased.ErrorFormat) → motive t | null | false |
IsNilpotent.of_pow | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_3} [inst : MonoidWithZero R] {x : R} {m : ℕ}, IsNilpotent (x ^ m) → IsNilpotent x | null | true |
Std.IterM.mapM.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β] [inst_1 : Monad n]
[inst_2 : MonadAttach n] [inst_3 : MonadLiftT m n] (f : β → n γ) (it : Std.IterM m β),
Std.IterM.mapM f it = Std.IterM.mapWithPostcondition (fun b => Std.Iterators.PostconditionT.attachLift (f b)) it | null | true |
CommRingCat.piFanIsLimit | Mathlib.Algebra.Category.Ring.Constructions | {ι : Type u} → (R : ι → CommRingCat) → CategoryTheory.Limits.IsLimit (CommRingCat.piFan R) | The categorical product of rings is the Cartesian product of rings.
| true |
unitInterval.symm_lt_comm | Mathlib.Topology.UnitInterval | ∀ {i j : ↑unitInterval}, unitInterval.symm i < j ↔ unitInterval.symm j < i | null | true |
RelSeries.mem_toList._simp_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r} {x : α}, (x ∈ s.toList) = (x ∈ s) | null | false |
DirectSum.fromAddMonoid | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → (DirectSum ι fun i => γ →+ β i) →+ γ →+ DirectSum ι fun i => β i | `fromAddMonoid φ` is the natural homomorphism from `γ` to `⨁ i, β i`
induced by a family `φ` of homomorphisms `γ → β i`.
Note that this is not an isomorphism. Not every homomorphism `γ →+ ⨁ i, β i` arises in this way. | true |
IsUnit.eq_one | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {a : M} [Subsingleton Mˣ], IsUnit a → a = 1 | null | true |
Set.mem_image_equiv._simp_1 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) | null | false |
ValuativeRel.exists_valuation_posSubmonoid_div_valuation_posSubmonoid_eq | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : ValuativeRel R] (γ : (ValuativeRel.ValueGroupWithZero R)ˣ),
∃ a b, (ValuativeRel.valuation R) ↑a / (ValuativeRel.valuation R) ↑b = ↑γ | null | true |
AddCommGroup.toDivisionAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G],
AddCommGroup.toDivisionAddCommMonoid =
{ toSubNegMonoid := inst.toSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯, add_comm := ⋯ } | null | true |
MonoidAlgebra.lift | Mathlib.Algebra.MonoidAlgebra.Basic | (R : Type u_1) →
(A : Type u_4) →
(M : Type u_7) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Algebra R A] → [inst_3 : Monoid M] → (M →* A) ≃ (MonoidAlgebra R M →ₐ[R] A) | Any monoid homomorphism `M →* A` can be lifted to an algebra homomorphism `R[M] →ₐ[R] A`. | true |
CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_inv | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (α : F ⟶ G) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
(α.naturality (CategoryTheory.CategoryStruct.comp f g)).inv =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | null | true |
Unitary.map_comp | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S]
[inst_3 : StarMul S] [inst_4 : Monoid T] [inst_5 : StarMul T] (g : S →⋆* T) (f : R →⋆* S),
Unitary.map (g.comp f) = (Unitary.map g).comp (Unitary.map f) | null | true |
Finset.centerMass_pair | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} {ι : Type u_5} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(i j : ι) (w : ι → R) (z : ι → E) [inst_3 : DecidableEq ι],
i ≠ j → {i, j}.centerMass w z = (w i / (w i + w j)) • z i + (w j / (w i + w j)) • z j | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrMFast.loop._unary | Batteries.Data.Vector.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
{n : ℕ} →
[Monad m] →
(α → β → m β) →
Vector α n →
(n_usize : USize) →
n_usize.toNat = n →
(_ : β) ×' (i : USize) ×' (_ : i.toNat ≤ n) ×' Vector β (n + 1) → m (Vector β... | null | false |
MeasureTheory.stoppedValue_stoppedProcess | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] {u : ι → Ω → β} {τ σ : Ω → WithTop ι}
[inst_1 : LinearOrder ι],
MeasureTheory.stoppedValue (MeasureTheory.stoppedProcess u τ) σ = fun ω =>
if σ ω ≠ ⊤ then MeasureTheory.stoppedValue u (fun ω => min (σ ω) (τ ω)) ω
else MeasureTheory.stoppedVa... | null | true |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_5 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | { obj := fun G => G.toProfinite,
map := fun {X Y} f =>
CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X)
{ toFun := ⇑(ProfiniteAddGrp.Hom.hom f), continuous_toFun := ⋯ },
map_id :=
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnected... | null | false |
Set.nonempty_image_addRight_neg_inter_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {s t : Set α} {a : α},
((fun x => x + -a) '' s ∩ t).Nonempty ↔ ((fun x => a + x) '' (-s) ∩ -t).Nonempty | null | true |
Std.Slice.foldlM_toArray | Init.Data.Slice.Lemmas | ∀ {γ : Type u} {α β : Type v} {m : Type u_1 → Type u_2} {δ : Type u_1} [inst : Monad m]
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
[Std.LawfulIteratorLoop α Id m] [Std.Iterators.Finite α Id] [LawfulMonad m] {s : Std.Slice γ} {init : δ}
{f : δ →... | null | true |
_private.Mathlib.Topology.Closure.0.exists_isClosed_iff.match_1_1 | Mathlib.Topology.Closure | ∀ {X : Type u_1} [inst : TopologicalSpace X] {p : Set X → Prop} (motive : (∃ t, IsClosed t ∧ p t) → Prop)
(x : ∃ t, IsClosed t ∧ p t), (∀ (w : Set X) (h : IsClosed w ∧ p w), motive ⋯) → motive x | null | false |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.ctorElimType | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | {motive : Lean.Elab.Tactic.Do.ClassifyInvariantUseResult✝ → Sort u} → ℕ → Sort (max 1 u) | null | false |
Mathlib.Tactic.Ring.CSLift.ctorIdx | Mathlib.Tactic.Ring.Basic | {α : Type u} → {β : outParam (Type u)} → Mathlib.Tactic.Ring.CSLift α β → ℕ | null | false |
GaloisConnection.toGaloisCoinsertion.eq_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(gc : GaloisConnection u l) (h : ∀ (b : β), l (u b) ≤ b),
gc.toGaloisCoinsertion h = { choice := fun x x_1 => l x, gc := gc, u_l_le := h, choice_eq := ⋯ } | null | true |
CategoryTheory.Pretriangulated.Triangle.functorIsoMk._proof_4 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
[inst_2 : CategoryTheory.Category.{u_3, u_1} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(iso₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ≅ B.comp Categ... | null | false |
ProbabilityTheory.Kernel.IsMarkovKernel.comp | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) [ProbabilityTheory.IsMarkovKernel η]
(κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsMarkovKernel κ], ProbabilityTheory.IsMarkovKernel (η.comp κ) | null | true |
CategoryTheory.Adjunction.leftAdjointIdIso_hom_app | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C₀] {F G : CategoryTheory.Functor C₀ C₀} (adj : F ⊣ G)
(e : G ≅ CategoryTheory.Functor.id C₀) (X : C₀),
(adj.leftAdjointIdIso e).hom.app X = CategoryTheory.CategoryStruct.comp (F.map (e.inv.app X)) (adj.counit.app X) | null | true |
CategoryTheory.Subobject.isoOfEq._proof_4 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} (X Y : CategoryTheory.Subobject B) (h : X = Y),
CategoryTheory.CategoryStruct.comp (Y.ofLE X ⋯) (X.ofLE Y ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Subobject.underlying.obj Y) | null | false |
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_2 | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A)
(p : Polynomial R), Polynomial.eval₂ (algebraMap R A) x p = (Polynomial.aeval x) p | null | false |
_private.Mathlib.Topology.Algebra.ProperAction.Basic.0.t2Space_quotient_mulAction_of_properSMul._simp_4 | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
Sbtw.trans_wbtw_left_ne | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] [IsDomain R] [Module.IsTorsionFree R V]
{w x y z : P}, Sbtw R w y z → Wbtw R w x y → x ≠ z | null | true |
ProbabilityTheory.gaussianReal_const_sub | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : Ω → ℝ},
ProbabilityTheory.HasLaw X (ProbabilityTheory.gaussianReal μ v) P →
∀ (y : ℝ), ProbabilityTheory.HasLaw (fun ω => y - X ω) (ProbabilityTheory.gaussianReal (y - μ) v) P | If `X` is a real random variable with Gaussian law with mean `μ` and variance `v`, then `y - X`
has Gaussian law with mean `y - μ` and variance `v`. | true |
ValuativeRel.srel_of_srel_of_rel | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] {x y z : R}, x <ᵥ y → y ≤ᵥ z → x <ᵥ z | **Alias** of `ValuativeRel.vlt_of_vlt_of_vle`. | true |
Aesop.RuleStats.mk.injEq | Aesop.Stats.Basic | ∀ (rule : Aesop.DisplayRuleName) (elapsed : Aesop.Nanos) (successful : Bool) (rule_1 : Aesop.DisplayRuleName)
(elapsed_1 : Aesop.Nanos) (successful_1 : Bool),
({ rule := rule, elapsed := elapsed, successful := successful } =
{ rule := rule_1, elapsed := elapsed_1, successful := successful_1 }) =
(rule = r... | null | true |
BitVec.instDecidableExistsBitVecSucc._proof_1 | Init.Data.BitVec.Decidable | ∀ {n : ℕ} (P : BitVec (n + 1) → Prop), (¬∀ (v : BitVec (n + 1)), ¬P v) ↔ ∃ v, P v | null | false |
Set.finite_iff_bddAbove_bddBelow | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_3} {s : Set α} [Nonempty α] [inst : Lattice α] [LocallyFiniteOrder α], s.Finite ↔ BddAbove s ∧ BddBelow s | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.