name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PartOrdEmb.isCardinalFiltered_iff | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ (κ : Cardinal.{u}) [inst : Fact κ.IsRegular] (X : PartOrdEmb),
PartOrdEmb.isCardinalFiltered κ X ↔ CategoryTheory.IsCardinalFiltered (↑X) κ | null | true |
ProbabilityTheory.condIndepFun_iff_condExp_inter_preimage_eq_mul | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'},
Measurable f →
Measurable g →
(... | null | true |
CategoryTheory.Bimon.instBimonObjXXMon | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (M : CategoryTheory.Bimon C) → CategoryTheory.BimonObj M.X.X | null | true |
CommMonCat.units._proof_1 | Mathlib.Algebra.Category.Grp.Adjunctions | ∀ (x : CommMonCat),
CommGrpCat.ofHom (Units.map (CommMonCat.Hom.hom (CategoryTheory.CategoryStruct.id x))) =
CategoryTheory.CategoryStruct.id ↧(↑x)ˣ | null | false |
AlgHom.toOpposite._proof_2 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : ∀ (x y : A), Commute (f x) (f y)) (x y : A),
(↑↑(f.toOpposite hf)).toFun (x * y) = (↑↑(f.toOpposite hf)).toFun x * (↑↑(f.toOpposite h... | null | false |
sub_one_mul_padicValNat_choose_eq_sub_sum_digits' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p k n : ℕ} [hp : Fact (Nat.Prime p)],
(p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum | **Kummer's Theorem**
Taking (`p - 1`) times the `p`-adic valuation of the binomial `n + k` over `k` equals the sum of the
digits of `k` plus the sum of the digits of `n` minus the sum of digits of `n + k`, all base `p`.
| true |
CategoryTheory.SingleFunctors.map_lift_shiftIso_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctorsLift | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{u_7, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] [inst_2 : CategoryTheory.Category.{u_5, u_3} E] {A : Type u_4}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | null | true |
Subtype.instTotalLE | Init.Data.Subtype.Order | ∀ {α : Type u} [inst : LE α] [i : Std.Total fun x1 x2 => x1 ≤ x2] {P : α → Prop}, Std.Total fun x1 x2 => x1 ≤ x2 | null | true |
CategoryTheory.Endofunctor.Coalgebra.Hom.id._proof_2 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
(V : CategoryTheory.Endofunctor.Coalgebra F),
CategoryTheory.CategoryStruct.comp V.str (F.map (CategoryTheory.CategoryStruct.id V.V)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id V.V) V.str | null | false |
_private.Mathlib.Data.Setoid.Basic.0.Setoid.mk_eq_bot._simp_1_1 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, (r₁ = r₂) = (⇑r₁ = ⇑r₂) | null | false |
InverseSystem.piSplitLE._proof_14 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {i : ι} [inst : PartialOrder ι], i ≤ i | null | false |
InnerProductSpace.toDual_apply_eq_toDualMap_apply | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (x : E), (InnerProductSpace.toDual 𝕜 E) x = (InnerProductSpace.toDualMap 𝕜 E) x | null | true |
_private.Mathlib.Topology.Constructions.SumProd.0.isOpenMap_inr._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s = (IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)) | null | false |
SimpleGraph.Subgraph.coeCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} → {G : SimpleGraph V} → (G' : G.Subgraph) → G'.coe.Copy G | A `Subgraph G` gives rise to a copy from the coercion to `G`. | true |
DiscreteQuotient.equivFinsetClopens | Mathlib.Topology.DiscreteQuotient | (X : Type u_2) →
[inst : TopologicalSpace X] →
[inst_1 : CompactSpace X] → DiscreteQuotient X ≃ ↑(Set.range (DiscreteQuotient.finsetClopens X)) | The discrete quotients of a compact space are in bijection with a subtype of the type of
`Finset (Clopens X)`.
TODO: show that this is precisely those finsets of clopens which form a partition of `X`.
| true |
ULiftable.up' | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} → {g : Type v₀ → Type v₁} → [ULiftable f g] → f PUnit.{u₀ + 1} → g PUnit.{v₀ + 1} | A version of `up` for a `PUnit` return type. | true |
SimpleGraph.map_neighborFinset_induce_of_neighborSet_subset | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {s : Set V} [inst : DecidablePred fun x => x ∈ s] [inst_1 : Fintype V] {G : SimpleGraph V}
[inst_2 : DecidableRel G.Adj] {v : ↑s},
G.neighborSet ↑v ⊆ s →
Finset.map (Function.Embedding.subtype fun x => x ∈ s) ((SimpleGraph.induce s G).neighborFinset v) =
G.neighborFinset ↑v | null | true |
List.pmap_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {p : { x // x ∈ l } → Prop} {f : (a : { x // x ∈ l }) → p a → β}
(H : ∀ a ∈ l.attach, p a), List.pmap f l.attach H = List.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) l ⋯ | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.errorMessage.match_6 | Mathlib.Tactic.Linter.TextBased | (motive : Mathlib.Linter.TextBased.StyleError✝ → Sort u_1) →
(err : Mathlib.Linter.TextBased.StyleError✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.adaptationNote✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.windowsLineEnding✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleErro... | null | false |
CategoryTheory.PreOneHypercover.inv_hom_h₁_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : F.I₀} (k : F.I₁ i j) {Z : C} (h : F.Y (e.hom.s₁ (e.inv.s₁ k)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₁ k) (CategoryTheory.CategoryStruct.comp (e.hom.h₁ (e.inv.s₁ k)) h) =
Categ... | null | true |
Polynomial.eraseLead_monomial | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] (i : ℕ) (r : R), ((Polynomial.monomial i) r).eraseLead = 0 | null | true |
AddSemiconjBy.unop | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {a x y : αᵃᵒᵖ},
AddSemiconjBy a x y → AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x) | null | true |
Equiv.sigmaSumDistrib_apply | Mathlib.Logic.Equiv.Sum | ∀ {ι : Type u_11} (α : ι → Type u_9) (β : ι → Type u_10) (p : (i : ι) × (α i ⊕ β i)),
(Equiv.sigmaSumDistrib α β) p = Sum.map (Sigma.mk p.fst) (Sigma.mk p.fst) p.snd | null | true |
Real.RingHom.unique | Mathlib.Algebra.Order.Archimedean.Real.Hom | Unique (ℝ →+* ℝ) | There exists no nontrivial ring homomorphism `ℝ →+* ℝ`. | true |
Num.mod.eq_3 | Mathlib.Data.Num.ZNum | ∀ (a b : PosNum), (Num.pos a).mod (Num.pos b) = a.mod' b | null | true |
Metric.exists_isBounded_image_of_tendsto | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_2} {β : Type u_3} [inst : PseudoMetricSpace β] {l : Filter α} {f : α → β} {x : β},
Filter.Tendsto f l (nhds x) → ∃ s ∈ l, Bornology.IsBounded (f '' s) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_filter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
CategoryTheory.Limits.prod.map_mono | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z)
[CategoryTheory.Mono f] [CategoryTheory.Mono g] [inst_3 : CategoryTheory.Limits.HasBinaryProduct W X]
[inst_4 : CategoryTheory.Limits.HasBinaryProduct Y Z], CategoryTheory.Mono (CategoryTheory.Limits.prod.map f g) | null | true |
List.step_iter_cons | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {x : β} {xs : List β}, (x :: xs).iter.step = ⟨Std.IterStep.yield xs.iter x, ⋯⟩ | null | true |
LieModule.rank_le_finrank | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : LieRingModule L M] [inst_8 : LieModule R L M] [inst_9 : Module.Finite R M] [inst_10 : Mo... | null | true |
CategoryTheory.Square.toArrowArrowFunctor._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.Square C} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.homMk φ.τ₁ φ.τ₃ ⋯)
(CategoryTheory.Arrow.mk (CategoryTheory.Arrow.homMk Y.f₁₂ Y.f₃₄ ⋯)).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheor... | null | false |
tacticSimp_wf | Init.WFTactics | Lean.ParserDescr | Unfold definitions commonly used in well founded relation definitions.
Since Lean 4.12, Lean unfolds these definitions automatically before presenting the goal to the
user, and this tactic should no longer be necessary. Calls to `simp_wf` can be removed or replaced
by plain calls to `simp`.
| true |
Set.Finite.isGδ_compl | Mathlib.Topology.Separation.GDelta | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} [T1Space X], s.Finite → IsGδ sᶜ | null | true |
LieAlgebra.Orthogonal.typeB | Mathlib.Algebra.Lie.Classical | (l : Type u_4) →
(R : Type u₂) →
[inst : DecidableEq l] →
[inst_1 : CommRing R] → [inst_2 : Fintype l] → LieSubalgebra R (Matrix (Unit ⊕ l ⊕ l) (Unit ⊕ l ⊕ l) R) | The classical Lie algebra of type B as a Lie subalgebra of matrices associated to the matrix
`JB`. | true |
CategoryTheory.Over.opEquivOpUnder._proof_4 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) {Z Y : (CategoryTheory.Under X)ᵒᵖ} (f : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Under.Hom.right f.unop).op
(CategoryTheory.Over.mk (Opposite.unop Y).hom.op).hom =
(CategoryTheory.Over.mk (Opposite.unop Z).hom.op).hom | null | false |
Array.PrefixTable.step | Batteries.Data.Array.Match | {α : Type u_1} → [BEq α] → (t : Array.PrefixTable α) → α → Fin (t.size + 1) → Fin (t.size + 1) | Transition function for the KMP matcher
Assuming we have an input `xs` with a suffix that matches the pattern prefix `t.pattern[:len]`
where `len : Fin (t.size+1)`. Then `xs.push x` has a suffix that matches the pattern prefix
`t.pattern[:t.step x len]`. If `len` is as large as possible then `t.step x len` will also b... | true |
preservesBinaryCoproducts_of_preservesInitial_and_pushouts | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasPushouts C]
[CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) F]
[... | A functor that preserves initial objects and pushouts preserves binary coproducts. | true |
Finset.sigmaLift | Mathlib.Data.Finset.Sigma | {ι : Type u_1} →
{α : ι → Type u_2} →
{β : ι → Type u_3} →
{γ : ι → Type u_4} → [DecidableEq ι] → (⦃i : ι⦄ → α i → β i → Finset (γ i)) → Sigma α → Sigma β → Finset (Sigma γ) | Lifts maps `α i → β i → Finset (γ i)` to a map `Σ i, α i → Σ i, β i → Finset (Σ i, γ i)`. | true |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_map_app_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) {X_1 Y : CategoryTheory.Functor J₂ C}
(f : X_1 ⟶ Y)... | null | true |
Inclusion.ExprInclusion.mk.sizeOf_spec | Mathlib.Tactic.Inclusion.Core.Types | ∀ (inclusion proof : Lean.Expr), sizeOf { inclusion := inclusion, proof := proof } = 1 + sizeOf inclusion + sizeOf proof | null | true |
MeasureTheory.measureReal_union_null | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
μ.real s₁ = 0 → μ.real s₂ = 0 → μ.real (s₁ ∪ s₂) = 0 | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.NonemptyCompacts.preconnectedSpace_iff._simp_1_2 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
Std.TreeMap.Raw.Equiv.minEntry?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.minEntry? = t₂.minEntry? | null | true |
Polynomial.C_mul_X_pow_eq_monomial | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, Polynomial.C a * Polynomial.X ^ n = (Polynomial.monomial n) a | null | true |
MeasureTheory.lintegral_liminf_le' | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ι : Type u_3} {f : ι → α → ENNReal}
{u : Filter ι} [u.IsCountablyGenerated],
(∀ (i : ι), AEMeasurable (f i) μ) →
∫⁻ (a : α), Filter.liminf (fun i => f i a) u ∂μ ≤ Filter.liminf (fun i => ∫⁻ (a : α), f i a ∂μ) u | **Fatou's lemma**, version with `AEMeasurable` functions. | true |
LeanSearchClient.LoogleResult.noConfusionType | LeanSearchClient.LoogleSyntax | Sort u → LeanSearchClient.LoogleResult → LeanSearchClient.LoogleResult → Sort u | null | false |
CategoryTheory.MorphismProperty.Under.instCreatesFiniteColimitsTopUnderForget._proof_1 | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) [CategoryTheory.Limits.HasPushouts T],
CategoryTheory.Limits.HasColimitsOfShape CategoryTheory.Limits.WalkingSpan (CategoryTheory.Under X) | null | false |
MvPolynomial.isWeightedHomogeneous_X | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M) (i : σ),
MvPolynomial.IsWeightedHomogeneous w (MvPolynomial.X i) (w i) | An indeterminate `i : σ` is weighted homogeneous of degree `w i`. | true |
TopologicalLattice.rec | Mathlib.Topology.Order.Lattice | {L : Type u_1} →
[inst : TopologicalSpace L] →
[inst_1 : Lattice L] →
{motive : TopologicalLattice L → Sort u} →
([toContinuousInf : ContinuousInf L] → [toContinuousSup : ContinuousSup L] → motive ⋯) →
(t : TopologicalLattice L) → motive t | null | false |
SimpleGraph.killCopies.edgeSet.instFintype | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} →
{W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → [Fintype ↑G.edgeSet] → Fintype ↑(G.killCopies H).edgeSet | null | true |
CategoryTheory.ObjectProperty.strictColimitsOfShape_bot | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [Nonempty J], ⊥.strictColimitsOfShape J = ⊥ | null | true |
Lean.Meta.Sym.Arith.CommSemiring.addFn?._inherited_default | Lean.Meta.Sym.Arith.Types | Option Lean.Expr | null | false |
HasSummableGeomSeries.rec | Mathlib.Analysis.SpecificLimits.Normed | {K : Type u_4} →
[inst : NonUnitalNormedRing K] →
{motive : HasSummableGeomSeries K → Sort u} →
((summable_geometric_of_norm_lt_one : ∀ (ξ : K), ‖ξ‖ < 1 → Summable fun x => (fun x => x * ξ)^[x] ξ) → motive ⋯) →
(t : HasSummableGeomSeries K) → motive t | null | false |
HNNExtension.NormalWord.ReducedWord.prod.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) (w : HNNExtension.NormalWord.ReducedWord G A B),
HNNExtension.NormalWord.ReducedWord.prod φ w =
HNNExtension.of w.head * (List.map (fun x => HNNExtension.t ^ ↑x.1 * HNNExtension.of x.2) w.toList).prod | null | true |
_private.Mathlib.Probability.Distributions.Gaussian.Multivariate.0.ProbabilityTheory.charFun_stdGaussian._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {α : Type u_1} (s : Finset α) (f : α → ℝ), ∑ i ∈ s, ↑(f i) = ↑(∑ i ∈ s, f i) | null | false |
MeasureTheory.FiniteMeasure.restrict_biUnion_finset | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_3} {μ : MeasureTheory.FiniteMeasure Ω} {T : Finset ι}
{s : ι → Set Ω},
(↑T).Pairwise (Function.onFun Disjoint s) →
(∀ (i : ι), MeasurableSet (s i)) → μ.restrict (⋃ i ∈ T, s i) = ∑ i ∈ T, μ.restrict (s i) | null | true |
MeasureTheory.Filtration.mono | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {i j : ι}
(f : MeasureTheory.Filtration ι m), i ≤ j → ↑f i ≤ ↑f j | null | true |
FinEnum.instUInt64 | Mathlib.Data.FinEnum | FinEnum UInt64 | null | true |
Prod.mk_le_swap._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x : α × β} {a : α} {b : β},
((b, a) ≤ x.swap) = ((a, b) ≤ x) | null | false |
Function.locallyFinsuppWithin.instAddGroup._proof_4 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddGroup Y]
(D : Function.locallyFinsuppWithin U Y) (n : ℕ), ⇑(n • D) = n • ⇑D | null | false |
CategoryTheory.Abelian.Ext.preadditiveYoneda_homologySequenceδ_singleTriangle_apply._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {n₀ n₁ : ℕ}, 1 + n₀ = n₁ → ↑n₀ + 1 = ↑n₁ | null | false |
Module.Flat.rTensor_exact | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
⦃N : Type u_1⦄ ⦃N' : Type u_2⦄ ⦃N'' : Type u_3⦄ [inst_4 : AddCommGroup N] [inst_5 : AddCommGroup N']
[inst_6 : AddCommGroup N''] [inst_7 : Module R N] [inst_8 : Module R N'] [inst_9 : Module R N''] ⦃f :... | If `M` is flat then `- ⊗ M` is an exact functor. | true |
Similar.comp_left_iff | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {F : Type u_6}
[inst_3 : FunLike F P₁ P₃] [DilationClass F P₁ P₃] (f : F), Similar (⇑f ∘ v₁) v₂ ↔ Similar v₁ v₂ | null | true |
WeierstrassCurve.Jacobian.negAddY._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | (2 + 1).AtLeastTwo | null | false |
Std.DTreeMap.Raw.alter | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] →
Std.DTreeMap.Raw α β cmp → (a : α) → (Option (β a) → Option (β a)) → Std.DTreeMap.Raw α β cmp | Modifies in place the value associated with a given key,
allowing creating new values and deleting values via an `Option` valued replacement function.
This function ensures that the value is used linearly.
| true |
_private.Lean.Meta.Tactic.Generalize.0.Lean.Meta.generalizeCore | Lean.Meta.Tactic.Generalize | Lean.MVarId → Array Lean.Meta.GeneralizeArg → Lean.Meta.TransparencyMode → Lean.MetaM (Array Lean.FVarId × Lean.MVarId) | Telescopic `generalize` tactic. It can simultaneously generalize many terms.
It uses `kabstract` to occurrences of the terms that need to be generalized.
| true |
List.set | Init.Prelude | {α : Type u_1} → List α → ℕ → α → List α | Replaces the value at (zero-based) index `n` in `l` with `a`. If the index is out of bounds, then
the list is returned unmodified.
Examples:
* `["water", "coffee", "soda", "juice"].set 1 "tea" = ["water", "tea", "soda", "juice"]`
* `["water", "coffee", "soda", "juice"].set 4 "tea" = ["water", "coffee", "soda", "juice"... | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.support_gaussianPDF._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
DoResultPRBC.recOn | Init.Core | {α β σ : Type u} →
{motive : DoResultPRBC α β σ → Sort u_1} →
(t : DoResultPRBC α β σ) →
((a : α) → (a_1 : σ) → motive (DoResultPRBC.pure a a_1)) →
((a : β) → (a_1 : σ) → motive (DoResultPRBC.return a a_1)) →
((a : σ) → motive (DoResultPRBC.break a)) → ((a : σ) → motive (DoResultPRBC.conti... | null | false |
IsMin.eq_of_ge | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, IsMin a → b ≤ a → a = b | null | true |
CondensedMod.ofSheafProfinite | Mathlib.Condensed.Explicit | (R : Type (u + 1)) →
[inst : Ring R] →
(F : CategoryTheory.Functor Profiniteᵒᵖ (ModuleCat R)) →
[CategoryTheory.Limits.PreservesFiniteProducts F] →
CategoryTheory.regularTopology.EqualizerCondition F → CondensedMod R | A `CondensedMod` version of `Condensed.ofSheafProfinite`. | true |
DifferentiableOn.congr | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {s : Set E},
DifferentiableOn 𝕜 f s → (∀ x ∈ s, f₁ x = f... | null | true |
ENNReal.Lp_add_le | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) (f g : ι → ENNReal) {p : ℝ},
1 ≤ p → (∑ i ∈ s, (f i + g i) ^ p) ^ (1 / p) ≤ (∑ i ∈ s, f i ^ p) ^ (1 / p) + (∑ i ∈ s, g i ^ p) ^ (1 / p) | **Minkowski inequality**: the `L_p` seminorm of the sum of two vectors is less than or equal
to the sum of the `L_p`-seminorms of the summands. A version for `ℝ≥0∞`-valued nonnegative
functions. | true |
CategoryTheory.Limits.WalkingMultispan.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u →
{J : CategoryTheory.Limits.MultispanShape} →
{x x_1 : CategoryTheory.Limits.WalkingMultispan J} →
x.Hom x_1 →
{J' : CategoryTheory.Limits.MultispanShape} →
{x' x'_1 : CategoryTheory.Limits.WalkingMultispan J'} → x'.Hom x'_1 → Sort u | null | false |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.skewAdjoint.isStarNormal_of_mem._simp_1_2 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u} [inst : Mul R] [inst_1 : HasDistribNeg R] {a b : R}, Commute a b → Commute (-a) b = True | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.IsPos.or_neg._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : CharZero R] (i : ι), b.height i ≠ 0 → 0 < b.height i ∨ 0 < -b.height i | null | false |
CochainComplex.homologyMap_homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | null | false |
LinearMap.toMatrixₛₗ₂'_symm | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : AddCommMonoid N₂] [inst_2 : Module R N₂] [inst_3 : Semiring R₁]
[inst_4 : Semiring R₂] [inst_5 : Semiring S₁] [inst_6 : Semiring S₂] [inst_7 : Module S₁... | null | true |
Equiv.Perm.SameCycle.equivalence | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} (f : Equiv.Perm α), Equivalence f.SameCycle | null | true |
CommHopfAlgCat.Hom.mk.inj | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u} {inst : CommRing R} {A B : CommHopfAlgCat R} {hom' hom'_1 : ↑A →ₐc[R] ↑B},
{ hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | true |
lt_iff_le_and_ne' | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, b < a ↔ b ≤ a ∧ a ≠ b | null | true |
DFinsupp.wellFoundedLT | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Preorder (α i)]
[∀ (i : ι), WellFoundedLT (α i)], (∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬a < 0) → WellFoundedLT (Π₀ (i : ι), α i) | null | true |
CochainComplex.shiftFunctorZero'_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n : ℤ) (h : n = 0)
(X : CochainComplex C ℤ) (i : ℤ),
((CochainComplex.shiftFunctorZero' C n h).inv.app X).f i = (HomologicalComplex.XIsoOfEq X ⋯).inv | null | true |
Lean.Widget.PanelWidgetInstance.mk.injEq | Lean.Widget.UserWidget | ∀ (toWidgetInstance : Lean.Widget.WidgetInstance) (range? : Option Lean.Lsp.Range) (name? : Option String)
(toWidgetInstance_1 : Lean.Widget.WidgetInstance) (range?_1 : Option Lean.Lsp.Range) (name?_1 : Option String),
({ toWidgetInstance := toWidgetInstance, range? := range?, name? := name? } =
{ toWidgetIns... | null | true |
MulEquiv.submonoidCongr.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {S T : Submonoid M} (h : S = T),
MulEquiv.submonoidCongr h = { toEquiv := Set.equivOfEq ⋯, map_mul' := ⋯ } | null | true |
Rep.coinvariantsTensorIndHom.eq_1 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u} [inst : CommRing k] {G H : Type u} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u, u, u} k G) (B : Rep.{u, u, u} k H),
Rep.coinvariantsTensorIndHom φ A B =
ModuleCat.ofHom
(Representation.Coinvariants.lift
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep.{u, u, ... | null | true |
SheafOfModules.LocalGeneratorsData.quasiCoherentData._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.LocallyFree | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : ∀ (X : C), CategoryTheory.HasSheafify (J.over X) AddCommGrpCat]
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R}
(q... | null | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findTactic?.merge._sparseCasesOn_3 | Lean.Server.CodeActions.Provider | {motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.MorphismProperty.Comma.Hom.noConfusionType | Mathlib.CategoryTheory.MorphismProperty.Comma | Sort u →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
{L : CategoryTheory.Functor A T} →
{R : ... | null | false |
Std.DTreeMap.Internal.Impl.filterMap._proof_10 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(St... | null | false |
LinearEquiv.domMulActCongrRight._proof_6 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8... | null | false |
MulZeroClass.rec | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
{motive : MulZeroClass M₀ → Sort u_1} →
([toMul : Mul M₀] →
[toZero : Zero M₀] →
(zero_mul : ∀ (a : M₀), 0 * a = 0) →
(mul_zero : ∀ (a : M₀), a * 0 = 0) →
motive { toMul := toMul, toZero := toZero, zero_mul := zero_mul, mul_zero := mul_zero }) →
(t... | null | false |
_private.Mathlib.Topology.Category.Stonean.Basic.0.Stonean.epi_iff_surjective._simp_1_6 | Mathlib.Topology.Category.Stonean.Basic | ∀ {a : Prop}, (¬¬a) = a | null | false |
CategoryTheory.toOverIsoToOverUnit_hom_app_left | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C),
(CategoryTheory.toOverIsoToOverUnit.hom.app X).left =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left
(((CategoryTheory.mateEquiv
(CategoryT... | null | true |
LinearIndependent.Maximal | Mathlib.LinearAlgebra.LinearIndependent.Defs | {ι : Type w} →
{R : Type u} →
[inst : Semiring R] →
{M : Type v} → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {v : ι → M} → LinearIndependent R v → Prop | A linearly independent family is maximal if there is no strictly larger linearly independent family.
| true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_add_gt.match_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (x = 0 → motive 0) → (∀ (d : ℕ), x = d.succ → motive d.succ) → motive x | null | false |
CategoryTheory.Coverage.mem_toGrothendieck | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {K : CategoryTheory.Coverage C} {X : C}
{S : CategoryTheory.Sieve X}, S ∈ K.toGrothendieck X ↔ K.Saturate X S | null | true |
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.isMulCommutative_iSup._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ p) = (x ∈ ↑p) | null | false |
ValuativeRel.instOrderBotValueGroupWithZero._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] (t : ValuativeRel.ValueGroupWithZero R), ⊥ ≤ t | null | false |
Fintype.decidableEqEmbeddingFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {β : Type u_2} (a b : α ↪ β), ⇑a = ⇑b ↔ a = b | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.