name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.HashMap.getKeyD_union_of_not_mem_left | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k fallback : α}, k ∉ m₁ → (m₁ ∪ m₂).getKeyD k fallback = m₂.getKeyD k fallback | null | true |
SFinKer.Hom.mk.sizeOf_spec | Mathlib.Probability.Kernel.Category.SFinKer | ∀ {X Y : SFinKer} (hom : ProbabilityTheory.Kernel X.carrier Y.carrier)
(property : ProbabilityTheory.IsSFiniteKernel hom),
sizeOf { hom := hom, property := property } = 1 + sizeOf hom + sizeOf property | null | true |
Module.Basis.norm_nonneg | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {K : Type u_1} {L : Type u_2} [inst : NormedField K] [inst_1 : Ring L] [inst_2 : Algebra K L] {ι : Type u_3}
[inst_3 : Fintype ι] [inst_4 : Nonempty ι] (B : Module.Basis ι K L) (x : L), 0 ≤ B.norm x | For any `K`-basis of `L`, and any `x : L`, we have `0 ≤ B.norm x`. | true |
AnalyticAt.smul | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {A : Type u_7}
[inst_5 : NormedRing A] [inst_6 : NormedAlgebra 𝕜 A] [inst_7 : Module A F] [IsBoundedSMul A F] [... | Scalar multiplication of one analytic function by another. | true |
Std.DHashMap.Raw.Const.getD | Std.Data.DHashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → (Std.DHashMap.Raw α fun x => β) → α → β → β | Tries to retrieve the mapping for the given key, returning `fallback` if no such mapping is present.
| true |
Plausible.Fin.Arbitrary._proof_1 | Plausible.Arbitrary | ∀ {n : ℕ} (__do_lift : ℕ), 0 ≤ min __do_lift n | null | false |
ContinuousMap.instSeminormedRing | Mathlib.Topology.ContinuousMap.Compact | {α : Type u_1} →
[inst : TopologicalSpace α] → [CompactSpace α] → {R : Type u_4} → [inst_2 : SeminormedRing R] → SeminormedRing C(α, R) | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Factors.0.Equiv.Perm.cycleFactorsAux.go._unsafe_rec | Mathlib.GroupTheory.Perm.Cycle.Factors | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] →
(f : Equiv.Perm α) →
(l : List α) →
(g : Equiv.Perm α) →
(∀ {x : α}, g x ≠ x → x ∈ l) →
(∀ {x : α}, g x ≠ x → f.cycleOf x = g.cycleOf x) →
{ pl // pl.prod = g ∧ (∀ g' ∈ pl, g'.IsCycle... | null | false |
Function.symm_apply_eq_iff._simp_1 | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {f : α → α}, (Std.Symm fun x1 x2 => f x1 = x2) = Function.Involutive f | null | false |
Int.negOnePow_one | Mathlib.Algebra.Ring.NegOnePow | Int.negOnePow 1 = -1 | null | true |
BoundedContinuousMapClass.recOn | Mathlib.Topology.ContinuousMap.Bounded.Basic | {F : Type u_2} →
{α : Type u_3} →
{β : Type u_4} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
[inst_2 : FunLike F α β] →
{motive : BoundedContinuousMapClass F α β → Sort u} →
(t : BoundedContinuousMapClass F α β) →
([toContinuou... | null | false |
ModuleCat.matrixEquivalence | Mathlib.RingTheory.Morita.Matrix | (R : Type u) →
{ι : Type v} →
[inst : Ring R] → [inst_1 : Fintype ι] → [inst_2 : DecidableEq ι] → ι → (ModuleCat R ≌ ModuleCat (Matrix ι ι R)) | `ModuleCat.toMatrixModCat R ι` and `MatrixModCat.toModuleCat R i` together form
an equivalence of categories. | true |
AddCon.liftOnAddUnits._proof_4 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {c : AddCon M} (u : AddUnits c.Quotient), ↑u + u.neg = 0 | null | false |
Nat.descFactorial_pos._simp_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ {n k : ℕ}, (0 < n.descFactorial k) = (k ≤ n) | null | false |
instZeroLieRinehartSubalgebra | Mathlib.Algebra.LieRinehartAlgebra.Subalgebra | (A : Type u_1) →
(L : Type u_2) → [inst : CommRing A] → [inst_1 : LieRing L] → [inst_2 : Module A L] → Zero (LieRinehartSubalgebra A L) | null | true |
Encodable.encodeSubtype.eq_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {P : α → Prop} [encA : Encodable α] (v : α) (property : P v),
Encodable.encodeSubtype ⟨v, property⟩ = Encodable.encode v | null | true |
Lean.Meta.AuxLemmas.recOn | Lean.Meta.Tactic.AuxLemma | {motive : Lean.Meta.AuxLemmas → Sort u} →
(t : Lean.Meta.AuxLemmas) →
((lemmas : Lean.PHashMap Lean.Meta.AuxLemmaKey (Lean.Name × List Lean.Name)) → motive { lemmas := lemmas }) →
motive t | null | false |
SSet.Truncated.FundamentalGroupoid.mk.inj | Mathlib.AlgebraicTopology.SimplicialSet.FundamentalGroupoid.Basic | ∀ {X : SSet.Truncated 2}
{pt pt_1 : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.FundamentalGroupoid._proof_1 })},
{ pt := pt } = { pt := pt_1 } → pt = pt_1 | null | true |
_private.Mathlib.MeasureTheory.Group.Action.0.MeasureTheory.smul_mem_ae._simp_1_1 | Mathlib.MeasureTheory.Group.Action | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s : Set α}, (s ∈ MeasureTheory.ae μ) = (μ sᶜ = 0) | null | false |
_private.Init.Data.Nat.Basic.0.Nat.add_one_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (n : ℕ) (motive : n + 1 = 0 → Prop) (a : n + 1 = 0), motive a | null | false |
Std.DTreeMap.size_diff_le_size_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
(t₁ \ t₂).size ≤ t₁.size | null | true |
UniformSpace.Completion.ring._proof_28 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
(a : UniformSpace.Completion α), 0 * a = 0 | null | false |
Finpartition.ofSetSetoid_parts | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Setoid α) (x : Finset α) [inst_1 : DecidableRel ⇑s],
(Finpartition.ofSetSetoid s x).parts = Finset.image (fun a => {b ∈ x | s a b}) x | null | true |
IsGreatest.maximal | Mathlib.Order.Minimal | ∀ {α : Type u_2} {x : α} {s : Set α} [inst : Preorder α], IsGreatest s x → Maximal (fun x => x ∈ s) x | null | true |
Commute.function_commute_mul_left | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Semigroup G] {a b : G}, Commute a b → Function.Commute (fun x => a * x) fun x => b * x | null | true |
Valuation.HasExtension.val_map_lt_iff | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u_1} {A : Type u_2} {ΓR : Type u_3} {ΓA : Type u_4} [inst : CommRing R] [inst_1 : Ring A]
[inst_2 : LinearOrderedCommMonoidWithZero ΓR] [inst_3 : LinearOrderedCommMonoidWithZero ΓA] [inst_4 : Algebra R A]
(vR : Valuation R ΓR) (vA : Valuation A ΓA) [vR.HasExtension vA] (x y : R),
vA ((algebraMap R A) ... | null | true |
MeasureTheory.StronglyAdapted.progMeasurable_of_discrete | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u : ι → Ω → β} [inst_2 : TopologicalSpace ι] [DiscreteTopology ι]
[SecondCountableTopology ι] [inst_5 : MeasurableSpace ι] [OpensMeasurableSpace ι]
[Topologi... | **Alias** of `MeasureTheory.StronglyAdapted.isStronglyProgressive_of_discrete`.
---
For filtrations indexed by a discrete order, `StronglyAdapted` and `IsStronglyProgressive` are
equivalent. This lemma provides `StronglyAdapted f u → IsStronglyProgressive f u`.
See `IsStronglyProgressive.stronglyAdapted` for the reve... | true |
CategoryTheory.ObjectProperty.IsSeparating.mono_iff | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.ObjectProperty C},
P.IsSeparating →
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono f ↔
∀ (G : C),
P G →
∀ (g₁ g₂ : G ⟶ X),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.Catego... | null | true |
_private.Mathlib.CategoryTheory.Localization.Triangulated.0.CategoryTheory.Triangulated.Localization.distinguished_cocone_triangle._simp_1_1 | Mathlib.CategoryTheory.Localization.Triangulated | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Std.TreeMap.Raw.minEntry! | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Inhabited (α × β)] → Std.TreeMap.Raw α β cmp → α × β | Tries to retrieve the key-value pair with the smallest key in the tree map, panicking if the map is
empty.
| true |
_private.Mathlib.NumberTheory.Zsqrtd.Basic.0.Zsqrtd.Nonnegg.match_1.eq_4 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ (motive : ℤ → ℤ → Sort u_1) (a a_1 : ℕ) (h_1 : (a b : ℕ) → motive (Int.ofNat a) (Int.ofNat b))
(h_2 : (a b : ℕ) → motive (Int.ofNat a) (Int.negSucc b)) (h_3 : (a b : ℕ) → motive (Int.negSucc a) (Int.ofNat b))
(h_4 : (a a_2 : ℕ) → motive (Int.negSucc a) (Int.negSucc a_2)),
(match Int.negSucc a, Int.negSucc a_1 w... | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.posSemidef_iff_re_sum_kernel'._proof_1_1 | Mathlib.Analysis.InnerProductSpace.Reproducing | 1 ≠ 0 | null | false |
ArithmeticFunction.natCoe_apply | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] {f : ArithmeticFunction ℕ} {x : ℕ}, ↑f x = ↑(f x) | null | true |
Equiv.prodEmbeddingDisjointEquivSigmaEmbeddingRestricted | Mathlib.Logic.Equiv.Embedding | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} → { f // Disjoint (Set.range ⇑f.1) (Set.range ⇑f.2) } ≃ (f : α ↪ γ) × (β ↪ ↑(Set.range ⇑f)ᶜ) | Pairs of embeddings with disjoint ranges are equivalent to a dependent sum of embeddings,
in which the second embedding cannot take values in the range of the first. | true |
Module.Basis.SmithNormalForm | Mathlib.LinearAlgebra.FreeModule.PID | {R : Type u_2} →
[inst : CommRing R] →
{M : Type u_3} →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Submodule R M → Type u_4 → ℕ → Type (max (max u_2 u_3) u_4) | A Smith normal form basis for a submodule `N` of a module `M` consists of
bases for `M` and `N` such that the inclusion map `N → M` can be written as a
(rectangular) matrix with `a` along the diagonal: in Smith normal form. | true |
Rep.coinvariantsFunctor_hom_ext | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Monoid G] {A : Rep.{w, u, v} k G} {M : ModuleCat k}
{f g : (Rep.coinvariantsFunctor k G).obj A ⟶ M},
CategoryTheory.CategoryStruct.comp ((Rep.coinvariantsMk k G).app A) f =
CategoryTheory.CategoryStruct.comp ((Rep.coinvariantsMk k G).app A) g →
f =... | null | true |
MeasureTheory.eLpNormEssSup_eq_iSup | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ε : Type u_8} [inst : ENorm ε],
(∀ (a : α), μ {a} ≠ 0) → ∀ (f : α → ε), MeasureTheory.eLpNormEssSup f μ = ⨆ a, ‖f a‖ₑ | null | true |
ProbabilityTheory.aemeasurable_of_integrable_exp_mul | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {u v : ℝ},
u ≠ v →
MeasureTheory.Integrable (fun ω => Real.exp (u * X ω)) μ →
MeasureTheory.Integrable (fun ω => Real.exp (v * X ω)) μ → AEMeasurable X μ | null | true |
Topology.WithUpper.ofUpper_le_ofUpper._simp_1 | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] {x y : Topology.WithUpper α},
(Topology.WithUpper.ofUpper x ≤ Topology.WithUpper.ofUpper y) = (x ≤ y) | null | false |
CategoryTheory.Functor.mapSquare_map_τ₄ | Mathlib.CategoryTheory.Square | ∀ {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 : CategoryTheory.Square C} (φ : X ⟶ Y), (F.mapSquare.map φ).τ₄ = F.map φ.τ₄ | null | true |
Std.ExtHashMap.getElem?_inter_of_not_mem_right | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, k ∉ m₂ → (m₁ ∩ m₂)[k]? = none | null | true |
_private.Lean.Meta.Tactic.Rfl.0.Lean.Meta.Rfl.initFn._sparseCasesOn_4._@.Lean.Meta.Tactic.Rfl.914023288._hygCtx._hyg.2 | Lean.Meta.Tactic.Rfl | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Plausible.retry._sunfold | Plausible.Testable | {p : Prop} → Plausible.Gen (Plausible.TestResult p) → ℕ → Plausible.Gen (Plausible.TestResult p) | null | false |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_mul_symm3 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {a b : EReal}, ContinuousAt (fun p => p.1 * p.2) (a, b) → ContinuousAt (fun p => p.1 * p.2) (-a, -b) | null | true |
Std.Antisymm.swap | Mathlib.Order.RelClasses | ∀ {α : Type u} (r : α → α → Prop) [Std.Antisymm r], Std.Antisymm (Function.swap r) | null | true |
Std.Internal.List.mem_iff_getValue?_eq_some | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [LawfulBEq α] {β : Type v} {k : α} {v : β} {l : List ((_ : α) × β)},
Std.Internal.List.DistinctKeys l → (⟨k, v⟩ ∈ l ↔ Std.Internal.List.getValue? k l = some v) | null | true |
CategoryTheory.ChosenPullbacksAlong.Over.associator_inv_left_fst_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
(R S T : CategoryTheory.Over X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left (CategoryTheory.MonoidalCategoryStruct.associator R S T).inv)
(CategoryTheory.CategoryStruct.c... | null | true |
PointedCone.ofSubmodule_sup | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] (S T : Submodule R E), ↑(S ⊔ T) = ↑S ⊔ ↑T | null | true |
_private.Init.Data.String.Decode.0.utf8DecodeChar?_append_eq_assemble₂ | Init.Data.String.Decode | ∀ {l : List UInt8} {b : ByteArray} (hl : l.length = 2),
ByteArray.utf8DecodeChar?.parseFirstByte l[0] = ByteArray.utf8DecodeChar?.FirstByte.oneMore →
(l.toByteArray ++ b).utf8DecodeChar? 0 = ByteArray.utf8DecodeChar?.assemble₂ l[0] l[1] | null | true |
_private.Std.Do.WP.Sound.0.OptionT.bind.match_1.eq_1 | Std.Do.WP.Sound | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (a : α) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match some a with
| some a => h_1 a
| none => h_2 ()) =
h_1 a | null | true |
CategoryTheory.Functor.OneHypercoverDenseData.sieve | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →... | Given `data : OneHypercoverDenseData F J₀ J X` and a morphism `f : F.obj X₀ ⟶ X`,
this is the sieve of `X₀` consisting of morphisms `g : Y₀ ⟶ X₀` such that there
exists `i₀ : data.I₀`, `q : F.obj Y₀ ⟶ F.obj (data.X i₀)` such that
we have a factorization `q ≫ data.f i₀ = F.map g ≫ f`. | true |
OnePoint.equivProjectivization._proof_2 | Mathlib.Topology.Compactification.OnePoint.ProjectiveLine | ∀ (K : Type u_1) [inst : DivisionRing K] (t : K), ![t, 1] ≠ 0 | null | false |
_private.Mathlib.Tactic.CategoryTheory.ToApp.0.Mathlib.Tactic.CategoryTheory.ToApp.initFn._@.Mathlib.Tactic.CategoryTheory.ToApp.3382173775._hygCtx._hyg.2 | Mathlib.Tactic.CategoryTheory.ToApp | IO Unit | null | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Lemmas.0.Metric.biUnion_lt_closedBall._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Lemmas | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ ⦃c : α⦄, c < a → c < b) = (a ≤ b) | null | false |
LocallyFiniteOrder.finset_mem_Ioc | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {inst : Preorder α} [self : LocallyFiniteOrder α] (a b x : α),
x ∈ LocallyFiniteOrder.finsetIoc a b ↔ a < x ∧ x ≤ b | `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` | true |
Semifield.toDivisionSemiring | Mathlib.Algebra.Field.Defs | {K : Type u_2} → [self : Semifield K] → DivisionSemiring K | null | true |
FirstOrder.Language.BoundedFormula.mapTermRel.eq_3 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} {β : Type v'} {g : ℕ → ℕ}
(ft : (n : ℕ) → L.Term (α ⊕ Fin n) → L'.Term (β ⊕ Fin (g n))) (fr : (n : ℕ) → L.Relations n → L'.Relations n)
(h : (n : ℕ) → L'.BoundedFormula β (g (n + 1)) → L'.BoundedFormula β (g n + 1)) (x l : ℕ) (_R : L.Relations l)
... | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.add | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ φ' : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
CategoryTheory.ShortComplex.RightHom... | Given right homology map data for morphisms `φ` and `φ'`, this is the induced
right homology map data for `φ + φ'`. | true |
_private.Lean.Level.0.Lean.Level.geq.go._unary | Lean.Level | (_ : Lean.Level) ×' Lean.Level → Bool | null | false |
CategoryTheory.Limits.limit.π_comp_eqToHom._proof_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} J] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} C] (F : CategoryTheory.Functor J C) {j j' : J},
j = j' → F.obj j = F.obj j' | null | false |
ContMDiffAt.curry_right | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [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] {E' : Type u_5} [inst_6 : NormedAddComm... | Curried `C^n` functions are `C^n` in the second coordinate. | true |
CategoryTheory.IsComonHom.hom_counit._autoParam | Mathlib.CategoryTheory.Monoidal.Comon_ | Lean.Syntax | null | false |
_private.Mathlib.Basic.Logic.Basic.0.dite_prop_iff_and._simp_1_2 | Mathlib.Basic.Logic.Basic | ∀ {p : Prop} {q : p → Prop} (h : p), (∀ (h' : p), q h') = q h | null | false |
Std.DTreeMap.Internal.Impl.ExplorationStep.recOn | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
{motive : Std.DTreeMap.Internal.Impl.ExplorationStep α β k → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl.ExplorationStep α β k) →
((a : α) →
(a_1 : k a = Ordering.lt) →
(a_... | null | false |
Lean.isMarkedBorrowed | Lean.Compiler.BorrowedAnnotation | Lean.Expr → Bool | null | true |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.dirichletUnitTheorem.logEmbedding_component_le._simp_1_1 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {r₁ r₂ : NNReal}, (↑r₁ ≤ ↑r₂) = (r₁ ≤ r₂) | null | false |
_private.Mathlib.Data.EReal.Operations.0.Mathlib.Meta.Positivity.evalERealAdd._proof_1 | Mathlib.Data.EReal.Operations | ∀ (α : Q(Type)) (zα : Q(Zero «$α»)) (__defeqres : PLift («$zα» =Q instZeroEReal)), «$zα» =Q instZeroEReal | null | false |
IsLocalization.AtPrime.equivQuotientMapOfIsMaximal_symm_apply_mk | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (Sₚ : Type u_4) [inst_4 : CommRing Sₚ] [inst_5 : Algebra S Sₚ]
[inst_6 : IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ] (P : Ideal S) [hPp : P.LiesOver p]
[inst_7 : ... | null | true |
SimpleGraph.Walk.concatRecAux.match_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | {V : Type u_1} →
{G : SimpleGraph V} →
{u : V} →
(motive : (v : V) → G.Walk u v → Sort u_2) →
(v : V) →
(x : G.Walk u v) →
(Unit → motive u SimpleGraph.Walk.nil) →
((v v_1 : V) → (h : G.Adj u v_1) → (p : G.Walk v_1 v) → motive v (SimpleGraph.Walk.cons h p)) → moti... | null | false |
Subgroup.relIndex_subgroupOf | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H K L : Subgroup G},
K ≤ L → (H.subgroupOf L).relIndex (K.subgroupOf L) = H.relIndex K | null | true |
EStateM.run_bind.match_1 | Init.Control.Lawful.Instances | {ε σ α : Type u_1} →
(motive : EStateM.Result ε σ α → Sort u_2) →
(x : EStateM.Result ε σ α) →
((x : α) → (s : σ) → motive (EStateM.Result.ok x s)) →
((e : ε) → (s : σ) → motive (EStateM.Result.error e s)) → motive x | null | false |
Sylow.ofCard._proof_1 | Mathlib.GroupTheory.Sylow | ∀ {G : Type u_1} [inst : Group G] [Finite G] {p : ℕ} [Fact (Nat.Prime p)] (H : Subgroup G),
Nat.card ↥H = p ^ (Nat.card G).factorization p → ¬p ∣ H.index | null | false |
CategoryTheory.Iso.map_inv_hom_id_assoc._to_dual_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{X Y : C} (e : X ≅ Y) (F : CategoryTheory.Functor C D) {Z : D} (h : Z ⟶ F.obj Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h (F.map e.inv)) (F.map e.hom) = h | null | false |
Polynomial.semiring._proof_16 | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R], autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
CategoryTheory.Limits.WalkingParallelFamily._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | (J : Type w) → [SizeOf J] → SizeOf (CategoryTheory.Limits.WalkingParallelFamily J) | null | false |
_private.Batteries.Data.Float.Lemmas.0.Float.beq_iff_ne_nan_and_eq._simp_1_1 | Batteries.Data.Float.Lemmas | ∀ {f f' : Float}, (f = f') = (f.toBits = f'.toBits) | null | false |
CategoryTheory.functorialSurjectiveInjectiveFactorizationData._proof_3 | Mathlib.CategoryTheory.MorphismProperty.Concrete | ∀ {X Y Z : CategoryTheory.Arrow (Type u_1)} (f : X ⟶ Y) (g : Y ⟶ Z),
(TypeCat.ofHom fun y =>
⟨(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Arrow.Hom.right (CategoryTheory.CategoryStruct.comp f g)))
↑y,
⋯⟩) =
CategoryTheory.CategoryStruct.comp
(TypeCat.ofHom fun y => ⟨(Categor... | null | false |
PeriodPair.isOpen_compl_lattice_sdiff | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair) {s : Set ℂ}, IsOpen (↑L.lattice \ s)ᶜ | null | true |
monotoneOn_descPochhammer_eval | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ {S : Type u_1} [inst : Ring S] [inst_1 : PartialOrder S] [IsStrictOrderedRing S] (n : ℕ),
MonotoneOn (fun x => Polynomial.eval x (descPochhammer S n)) (Set.Ici (↑n - 1)) | `descPochhammer S n` is monotone on `[n-1, ∞)`. | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.instQuasiIsoIntι._proof_3 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] [inst_3 : CategoryTheory.Mono f]
(n₀ : ℤ) [inst_4 : K.IsStrictlyGE (n₀ + 1)] [inst_5 : L.IsStrictlyGE (n₀ + 1)] (i : ℤ) (q : ℕ),
((... | null | false |
RelIso.cast_toEquiv | Mathlib.Order.RelIso.Basic | ∀ {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} (h₁ : α = β) (h₂ : r ≍ s),
(RelIso.cast h₁ h₂).toEquiv = Equiv.cast h₁ | null | true |
Mathlib.Meta.FunProp.FunctionTheorem.noConfusionType | Mathlib.Tactic.FunProp.Theorems | Sort u → Mathlib.Meta.FunProp.FunctionTheorem → Mathlib.Meta.FunProp.FunctionTheorem → Sort u | null | false |
balancedHull_mono | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] {s t : Set E},
s ⊆ t → (balancedHull 𝕜) s ⊆ (balancedHull 𝕜) t | null | true |
Array.flatMap_push | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {x : α} {f : α → Array β},
Array.flatMap f (xs.push x) = Array.flatMap f xs ++ f x | null | true |
CategoryTheory.Functor.flip₂₃Functor._proof_4 | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_8} {C₂ : Type u_1} {C₃ : Type u_2} {E : Type u_4} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_5, u_1} C₂] [inst_2 : CategoryTheory.Category.{u_6, u_2} C₃]
[inst_3 : CategoryTheory.Category.{u_3, u_4} E]
{X Y : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | false |
MvPowerSeries.instModuleRestricted._proof_3 | Mathlib.RingTheory.MvPowerSeries.Restricted | ∀ {R : Type u_1} [inst : NormedRing R] {σ : Type u_2} [inst_1 : IsUltrametricDist R] (c : σ → ℝ)
(f : MvPowerSeries.Restricted R c), 1 • f = f | null | false |
QuadraticMap.Isometry.snd._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Prod | ∀ {R : Type u_3} (M₁ : Type u_4) {M₂ : Type u_2} {P : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid P] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R P] (Q₂ : QuadraticMap R M₂ P) (m₁ : M₁ × M₂),
Q₂ ((LinearMap.snd R M₁ M₂).toFu... | null | false |
BialgCat.leftUnitor_def | Mathlib.Algebra.Category.BialgCat.Monoidal | ∀ (R : Type u) [inst : CommRing R] (X : BialgCat R),
CategoryTheory.MonoidalCategoryStruct.leftUnitor X = (Bialgebra.TensorProduct.lid R X.carrier).toBialgIso | null | true |
CategoryTheory.ObjectProperty.extensionProduct_iff | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P Q : Categor... | null | true |
_aux_Init_Notation___unexpand_GT_gt_1 | Init.Notation | Lean.PrettyPrinter.Unexpander | null | false |
IntermediateField.powerBasisAux._proof_2 | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L] {x : L}
(hx : IsIntegral K x), (AdjoinRoot.powerBasis ⋯).dim = (AdjoinRoot.powerBasis ⋯).dim | null | false |
ProbabilityTheory.CondIndepFun | Mathlib.Probability.Independence.Conditional | {Ω : Type u_1} →
(m' : MeasurableSpace Ω) →
{mΩ : MeasurableSpace Ω} →
[StandardBorelSpace Ω] →
m' ≤ mΩ →
{β : Type u_3} →
{γ : Type u_4} →
[MeasurableSpace β] →
[MeasurableSpace γ] →
(Ω → β) →
(Ω → γ) →
... | Two functions are conditionally independent if the two measurable space structures they generate
are conditionally independent. For a function `f` with codomain having measurable space structure
`m`, the generated measurable space structure is `m.comap f`.
See `ProbabilityTheory.condIndepFun_iff`.
We use the notation `... | true |
Filter.Tendsto.arccos_nhdsGE | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {α : Type u_1} {l : Filter α} {x : ℝ} {f : α → ℝ},
Filter.Tendsto f l (nhdsWithin x (Set.Ici x)) →
Filter.Tendsto (fun x => Real.arccos (f x)) l (nhdsWithin (Real.arccos x) (Set.Iic (Real.arccos x))) | null | true |
_private.Init.Data.List.Sublist.0.List.infix_iff_prefix_suffix.match_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α} (motive : l₁ <:+: l₂ → Prop) (x : l₁ <:+: l₂),
(∀ (w t : List α) (e : w ++ l₁ ++ t = l₂), motive ⋯) → motive x | null | false |
leftTotal_empty._simp_1 | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (R : α → β → Prop) [IsEmpty α], Relator.LeftTotal R = True | null | false |
AlgebraicGeometry.StructureSheaf.const_ext | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f₁ f₂ : M} {g₁ g₂ : R}
{U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)} {hu₁ : U ≤ PrimeSpectrum.basicOpen g₁}
{hu₂ : U ≤ PrimeSpectrum.basicOpen g₂},
g₂ • f₁ = g₁ • f₂ →
AlgebraicGeometry.StructureSheaf... | null | true |
CategoryTheory.ExactPairing.evaluation_coevaluation' | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {X Y : C}
[self : CategoryTheory.ExactPairing X Y],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight CategoryTheory.ExactPairing.coevaluation' X)
(CategoryTheory... | null | true |
Finset.HasAntidiagonal.mem_antidiagonal._simp_1 | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_1} {inst : Add A} [self : Finset.HasAntidiagonal A] {n : A} {a : A × A},
(a ∈ Finset.HasAntidiagonal.antidiagonal n) = (a.1 + a.2 = n) | null | false |
CategoryTheory.CreatesColimitsOfSize.CreatesColimitsOfShape | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} →
[self : CategoryTheory.CreatesColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F] →
{J : Type w} → [inst_2 : CategoryTheory.Cat... | null | true |
Ordinal.natCast_mul_omega0 | Mathlib.SetTheory.Ordinal.Principal | ∀ {n : ℕ}, 0 < n → ↑n * Ordinal.omega0 = Ordinal.omega0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.