name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CommRingCat.Colimits.colimitIsColimit._proof_1 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(s : CategoryTheory.Limits.Cocone F) (j : J),
CategoryTheory.CategoryStruct.comp ((CommRingCat.Colimits.colimitCocone F).ι.app j)
(CommRingCat.Colimits.descMorphism F s) =
s.ι.app j | null | false |
Frm.hom_ext | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} {f g : X ⟶ Y}, Frm.Hom.hom f = Frm.Hom.hom g → f = g | null | true |
Pi.instConvexSpaceForall._proof_2 | Mathlib.Geometry.Convex.ConvexSpace.Prod | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {ι : Type u_2}
{X : ι → Type u_3} [inst_3 : (i : ι) → Convexity.ConvexSpace R (X i)]
(f : Convexity.StdSimplex R (Convexity.StdSimplex R ((i : ι) → X i))),
(fun i =>
Convexity.iConvexComb (Convexity.StdSimplex.ma... | null | false |
IsDedekindDomain.HeightOneSpectrum.adicAbv_coe_le_one | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) {b : NNReal}
(hb : 1 < b) (r : R), (v.adicAbv hb) ((algebraMap R K) r) ≤ 1 | null | true |
DFinsupp.le_iff | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : DecidableEq ι] [inst_4 : (i : ι) → (x : α i) → Decidable (x ≠ 0)]
{f g : Π₀ (i : ι), α i}, f ≤ g ↔ ∀ i ∈ f.support, f i ≤ g i | null | true |
CategoryTheory.Limits.equalizer.fork_ι | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
(CategoryTheory.Limits.equalizer.fork f g).ι = CategoryTheory.Limits.equalizer.ι f g | null | true |
QuasilinearOn.dual | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LE β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasilinearOn 𝕜 s f → QuasilinearOn 𝕜 s (⇑OrderDual.toDual ∘ f) | null | true |
Matrix.toMvPolynomial_totalDegree_le | Mathlib.Algebra.Module.LinearMap.Polynomial | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : CommSemiring R] (M : Matrix m n R) (i : m),
(M.toMvPolynomial i).totalDegree ≤ 1 | null | true |
LinearMap.toMatrixOrthonormal | Mathlib.Analysis.InnerProductSpace.Adjoint | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
{n : Type u_6} →
[inst_3 : Fintype n] →
[DecidableEq n] →
[inst_5 : FiniteDimensional 𝕜 E] → OrthonormalBasis n 𝕜 E → (E... | The star algebra equivalence between the linear endomorphisms of finite-dimensional inner
product space and square matrices induced by the choice of an orthonormal basis. | true |
Std.Async.MaybeTask.pure | Std.Async.Basic | {α : Type} → α → Std.Async.MaybeTask α | null | true |
MeasureTheory.Submartingale.ae_tendsto_limitProcess | Mathlib.Probability.Martingale.Convergence | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ℱ : MeasureTheory.Filtration ℕ m0}
{f : ℕ → Ω → ℝ} {R : NNReal} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.Submartingale f ℱ μ →
(∀ (n : ℕ), MeasureTheory.eLpNorm (f n) 1 μ ≤ ↑R) →
∀ᵐ (ω : Ω) ∂μ, Filter.Tendsto (fun n => f n ω)... | **Almost everywhere martingale convergence theorem**: An L¹-bounded submartingale converges
almost everywhere to a `⨆ n, ℱ n`-measurable function. | true |
CategoryTheory.MonadHom.ext_iff | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {T₁ T₂ : CategoryTheory.Monad C}
{x y : CategoryTheory.MonadHom T₁ T₂}, x = y ↔ x.app = y.app | null | true |
CategoryTheory.IsPullback.paste_twist_right | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z S : C} {f : X ⟶ S} {g : Y ⟶ S} {i : Z ⟶ S} {Pfg : C}
{fstfg : Pfg ⟶ X} {sndfg : Pfg ⟶ Y},
CategoryTheory.IsPullback fstfg sndfg f g →
∀ {Pfi : C} {fstfi : Pfi ⟶ X} {sndfi : Pfi ⟶ Z},
CategoryTheory.IsPullback fstfi sndfi f i →
∀ {R... | The main objects in this lemma fit in the following commutative diagram:
```
Pfg -------> X <------- Pfi
| | |
| f |
↓ ↓ ↓
Y --- g --> S <-- i --- Z
\ /
-- --
\ /
-- R --
```
Suppose the two ... | true |
_private.Mathlib.GroupTheory.GroupAction.MultiplePrimitivity.0.MulAction.isMultiplyPreprimitive_congr._simp_1_3 | Mathlib.GroupTheory.GroupAction.MultiplePrimitivity | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s : Set α} {m : M},
(m ∈ fixingSubgroup M s) = ∀ y ∈ s, m • y = y | null | false |
WeierstrassCurve.Projective.neg_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P : Fin 3 → R},
W'.Equation P → P 2 = 0 → W'.neg P = -P 1 • ![0, 1, 0] | null | true |
Std.DTreeMap.Internal.Impl.minEntry?.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Intern... | null | false |
Pi.cancelCommMonoid | Mathlib.Algebra.Group.Pi.Basic | {I : Type u} → {f : I → Type v₁} → [(i : I) → CancelCommMonoid (f i)] → CancelCommMonoid ((i : I) → f i) | null | true |
QuotientGroup.quotientBot_symm_apply | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : Group G] (a : G), QuotientGroup.quotientBot.symm a = ↑a | null | true |
OrderIso.ofClass | Mathlib.Order.Hom.Basic | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} → [inst : LE α] → [inst_1 : LE β] → [inst_2 : EquivLike F α β] → [OrderIsoClass F α β] → F → α ≃o β | Turn an element of a type `F` satisfying `OrderIsoClass F α β` into an actual
`OrderIso`. This is declared as the default coercion from `F` to `α ≃o β`. | true |
ISize.toInt16_or | Init.Data.SInt.Bitwise | ∀ (a b : ISize), (a ||| b).toInt16 = a.toInt16 ||| b.toInt16 | null | true |
Lean.Order.sup_le | Init.Internal.Order.Basic | ∀ {α : Sort u} [inst : Lean.Order.CompleteLattice α] {x : α} (c : α → Prop),
(∀ (y : α), c y → Lean.Order.PartialOrder.rel y x) → Lean.Order.PartialOrder.rel (Lean.Order.CompleteLattice.sup c) x | null | true |
MvQPF.Quot1.map | Mathlib.Data.QPF.Multivariate.Constructions.Quot | {n : ℕ} →
{F : TypeVec.{u} n → Type u} →
(R : ⦃α : TypeVec.{u} n⦄ → F α → F α → Prop) →
[inst : MvFunctor F] →
(∀ ⦃α β : TypeVec.{u} n⦄ (a b : F α) (f : α.Arrow β), R a b → R (MvFunctor.map f a) (MvFunctor.map f b)) →
⦃α β : TypeVec.{u} n⦄ → α.Arrow β → MvQPF.Quot1 R α → MvQPF.Quot1 R β | `map` of the `Quot1` functor | true |
Finset.sum_eq_sum_iff_single | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_2} {s : Finset ι} [inst : AddCommMonoid M] [IsRightCancelAdd M] {f g : ι → M} {i : ι},
i ∈ s → (∀ j ∈ s, j ≠ i → f j = g j) → (∑ j ∈ s, f j = ∑ j ∈ s, g j ↔ f i = g i) | null | true |
Real.one_le_cosh._simp_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (x : ℝ), (1 ≤ Real.cosh x) = True | null | false |
Lean.Compiler.LCNF.SimpleGroundExpr.ctorElim | Lean.Compiler.LCNF.SimpleGroundExpr | {motive : Lean.Compiler.LCNF.SimpleGroundExpr → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Compiler.LCNF.SimpleGroundExpr) →
ctorIdx = t.ctorIdx → Lean.Compiler.LCNF.SimpleGroundExpr.ctorElimType ctorIdx → motive t | null | false |
CategoryTheory.Precoverage.instPartialOrder._proof_1 | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (a b : CategoryTheory.Precoverage C),
(fun A B => A.coverings ≤ B.coverings) a b ∧ ¬(fun A B => A.coverings ≤ B.coverings) b a ↔
a.coverings ≤ b.coverings ∧ ¬b.coverings ≤ a.coverings | null | false |
fourier_gaussian_innerProductSpace | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ {b : ℂ} {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : FiniteDimensional ℝ V]
[inst_3 : MeasurableSpace V] [inst_4 : BorelSpace V],
0 < b.re →
∀ (w : V),
FourierTransform.fourier (fun v => Complex.exp (-b * ↑‖v‖ ^ 2)) w =
(↑Real.pi / b) ^ (↑(Module.finran... | null | true |
HomologicalComplex.homotopyCofiber.inrCompHomotopy._proof_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel],
(∀ (j : ι), ∃ i, c.Rel i j) →
∀ (j : ι),
... | null | false |
Con.group.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Group M] (c : Con M),
c.group =
{ toMonoid := c.monoid, toInv := c.hasInv, toDiv := c.hasDiv, toZPow := ZPow.ofPow, div_eq_mul_inv := ⋯,
zpow_zero' := ⋯, zpow_succ' := ⋯, zpow_neg' := ⋯, inv_mul_cancel := ⋯ } | null | true |
AlgebraicGeometry.QuasiCompactCover.instOfIsEmptyCarrierCarrierCommRingCat | Mathlib.AlgebraicGeometry.Cover.QuasiCompact | ∀ {S : AlgebraicGeometry.Scheme} {𝒰 : CategoryTheory.PreZeroHypercover S} [IsEmpty ↥S],
AlgebraicGeometry.QuasiCompactCover 𝒰 | null | true |
SaturatedSubmonoid.mem_toSubmonoid._simp_2 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : MulOneClass M] {s : SaturatedSubmonoid M} {x : M}, (x ∈ s.toSubmonoid) = (x ∈ s) | null | false |
Sublattice.instDistribLatticeCoe._proof_2 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : DistribLattice α] (L : Sublattice α) {x y : ↥L}, ↑x ≤ ↑y ↔ ↑x ≤ ↑y | null | false |
String.apply_skipPrefixWhile_prop | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String} {h : s.skipPrefixWhile P ≠ s.endPos},
¬P ((s.skipPrefixWhile P).get h) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.IsMatching.coeSubgraph._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), (↑a ∈ S) = True | null | false |
_private.Mathlib.Order.RelSeries.0.LTSeries.apply_add_index_le_apply_add_index_nat._proof_1_6 | Mathlib.Order.RelSeries | ∀ (p : LTSeries ℕ) (j : ℕ), j + 1 < p.length + 1 → j < p.length + 1 | null | false |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.dist_le_distortion_mul._simp_1_2 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), ↑(nndist x y) = dist x y | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.subcomplex_le_horn_iff._proof_1_4 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ} (S : Finset (Fin (n + 1 + 1))), S.card = n + 1 → Sᶜ.card + S.card = n + 1 + 1 → Sᶜ.card = 1 | null | false |
ContinuousAffineMap.instNormedSpace._proof_1 | Mathlib.Analysis.Normed.Affine.ContinuousAffineMap | ∀ {𝕜 : Type u_1} {W : Type u_2} [inst : SeminormedAddCommGroup W] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 W], SMulCommClass 𝕜 𝕜 W | null | false |
Nat.count_monotone | Mathlib.Data.Nat.Count | ∀ (p : ℕ → Prop) [inst : DecidablePred p], Monotone (Nat.count p) | null | true |
invertibleDiv | Mathlib.Algebra.GroupWithZero.Invertible | {α : Type u} → [inst : GroupWithZero α] → (a b : α) → [Invertible a] → [Invertible b] → Invertible (a / b) | `b / a` is the inverse of `a / b` | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.normal | Std.Sync.Channel | {α : Type} → IO.Promise (Option α) → Std.CloseableChannel.Consumer✝ α | null | true |
FractionalIdeal.wrapped._@.Mathlib.RingTheory.FractionalIdeal.Basic.1107666208._hygCtx._hyg.2 | Mathlib.RingTheory.FractionalIdeal.Basic | Subtype (Eq @FractionalIdeal.definition✝) | null | false |
sq_tsub_sq | Mathlib.Algebra.Order.Ring.Canonical | ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : PartialOrder R] [CanonicallyOrderedAdd R] [inst_3 : Sub R]
[OrderedSub R] [Std.Total fun x1 x2 => x1 ≤ x2] [AddLeftReflectLE R] (a b : R), a ^ 2 - b ^ 2 = (a + b) * (a - b) | The `tsub` version of `sq_sub_sq`. Notably, this holds for `Nat` and `NNReal`. | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder.0.CStarAlgebra.convexOn_ringInverse._proof_1_8 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] ⦃x : A⦄,
IsStrictlyPositive x → IsStrictlyPositive (Ring.inverse x) | null | false |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.false | Lean.Meta.InferType | Lean.Meta.ArrowPropResult✝ | The expression is definitely *not* of the form `A_1 -> ... -> A_n -> B`
where `B` is a proposition.
| true |
Filter.pi_inj | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)} [∀ (i : ι), (f₁ i).NeBot],
Filter.pi f₁ = Filter.pi f₂ ↔ f₁ = f₂ | null | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.NF.zero_of_zero._simp_1_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ {o : ONote}, o.NFBelow 0 = (o = 0) | null | false |
Nat.prod_pow_factorization_eq_self | Mathlib.Data.Nat.Factorization.Defs | ∀ {f : ℕ →₀ ℕ}, (∀ p ∈ f.support, Nat.Prime p) → (f.prod fun x1 x2 => x1 ^ x2).factorization = f | **Alias** of `Nat.factorization_prod_pow_eq_self`.
---
Any Finsupp `f : ℕ →₀ ℕ` whose support is in the primes is equal to the factorization of
the product `∏ (a : ℕ) ∈ f.support, a ^ f a`. | true |
Std.DTreeMap.Internal.Impl.Const.alter._proof_22 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} (sz : ℕ) (k' : α) (v' : β) (l' r' : Std.DTreeMap.Internal.Impl α fun x => β),
(Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced → r'.Balanced | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.Reason.yes.elim | Std.Time.Format.Basic | {motive : Std.Time.Reason✝ → Sort u} →
(t : Std.Time.Reason✝) → Std.Time.Reason.ctorIdx✝ t = 0 → motive Std.Time.Reason.yes✝ → motive t | null | false |
Lean.Elab.Term.MVarErrorKind.hole.elim | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.MVarErrorKind → Sort u} →
(t : Lean.Elab.Term.MVarErrorKind) → t.ctorIdx = 1 → motive Lean.Elab.Term.MVarErrorKind.hole → motive t | null | false |
commGroupOfIsUnit._proof_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [hM : CommMonoid M] (h : ∀ (a : M), IsUnit a) (a b : M), a / b = a * b⁻¹ | null | false |
Lean.Elab.Command.AssertExists.mk.injEq | Lean.Elab.AssertExists | ∀ (isDecl : Bool) (givenName modName : Lean.Name) (isDecl_1 : Bool) (givenName_1 modName_1 : Lean.Name),
({ isDecl := isDecl, givenName := givenName, modName := modName } =
{ isDecl := isDecl_1, givenName := givenName_1, modName := modName_1 }) =
(isDecl = isDecl_1 ∧ givenName = givenName_1 ∧ modName = modN... | null | true |
Lean.Meta.Grind.EMatch.State.delayedThmInsts | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → Lean.PHashMap Lean.Meta.Sym.ExprPtr (List Lean.Meta.Grind.DelayedTheoremInstance) | Delayed instantiations is a mapping from guards to theorems that are waiting them
to become `True`.
| true |
Lean.Elab.Term.Do.mkIte | Lean.Elab.Do.Legacy | Lean.Syntax →
Lean.Syntax →
Lean.Syntax →
Lean.Elab.Term.Do.CodeBlock → Lean.Elab.Term.Do.CodeBlock → Lean.Elab.TermElabM Lean.Elab.Term.Do.CodeBlock | null | true |
_private.Mathlib.Algebra.Module.Torsion.PrimaryComponent.0.Ideal.iSup_primaryComponent_eq_top._simp_1_8 | Mathlib.Algebra.Module.Torsion.PrimaryComponent | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
_private.Mathlib.Data.TypeVec.0.TypeVec.prod.fst.match_1.eq_1 | Mathlib.Data.TypeVec | ∀ (motive : (x : ℕ) → TypeVec.{u_1} x → TypeVec.{u_1} x → Fin2 x → Sort u_2) (n : ℕ) (α β : TypeVec.{u_1} n.succ)
(i : Fin2 n) (h_1 : (n : ℕ) → (α β : TypeVec.{u_1} n.succ) → (i : Fin2 n) → motive n.succ α β i.fs)
(h_2 : (n : ℕ) → (x x_1 : TypeVec.{u_1} n.succ) → motive n.succ x x_1 Fin2.fz),
(match n.succ, α, β,... | null | true |
Lean.Level.any | Lean.Level | Lean.Level → (Lean.Level → Bool) → Bool | null | true |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.instBEqLambdaTheoremArgs.beq.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive : Mathlib.Meta.FunProp.LambdaTheoremArgs → Mathlib.Meta.FunProp.LambdaTheoremArgs → Sort u_1) →
(x x_1 : Mathlib.Meta.FunProp.LambdaTheoremArgs) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremArgs.id Mathlib.Meta.FunProp.LambdaTheoremArgs.id) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremAr... | null | false |
MeasurableInf | Mathlib.MeasureTheory.Order.Lattice | (M : Type u_1) → [MeasurableSpace M] → [Min M] → Prop | We say that a type has `MeasurableInf` if `(c ⊓ ·)` and `(· ⊓ c)` are measurable functions.
For a typeclass assuming measurability of `uncurry (· ⊓ ·)` see `MeasurableInf₂`. | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj.0.DependsOn.lmarginalPartialTraj_of_le._proof_1_5 | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {a b : ℕ} (c : ℕ) (x : (n : ℕ) → X n) (y : (i : ↥(Finset.Ioc b c)) → X ↑i) (i : ℕ),
a ≤ b → i ≤ a → ∀ (h : b < i ∧ i ≤ c), y ⟨i, ⋯⟩ = x i | null | false |
smul_mul_smul | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_5} {β : Type u_6} [inst : Mul α] [inst_1 : Mul β] [inst_2 : SMul α β] [IsScalarTower α β β]
[IsScalarTower α α β] [SMulCommClass α β β] (a : α) (b : β) (c : α) (d : β), a • b * c • d = (a * c) • (b * d) | **Alias** of `smul_mul_smul_comm`.
---
Note that the `IsScalarTower α β β` and `SMulCommClass α β β` typeclass arguments are usually
satisfied by `Algebra α β`. | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.nameNotRoundtrippable | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Name → Bool | null | true |
CategoryTheory.Limits.colimit.hom_ext_iff | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F] {X : C}
{f f' : CategoryTheory.Limits.colimit F ⟶ X},
f = f' ↔
∀ (j : J),
CategoryTheory.CategoryStruct.comp... | null | true |
_private.Mathlib.Analysis.Normed.Module.Basic.0.NormedSpace.unbounded_univ.match_1_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] (R : ℝ) (motive : (∃ x, R < ‖x‖) → Prop) (x : ∃ x, R < ‖x‖),
(∀ (x : E) (hx : R < ‖x‖), motive ⋯) → motive x | null | false |
ConvexOn.sup | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
[PosSMulStrictMono 𝕜 β] {s : Set E} {f g : E → β}, ConvexOn 𝕜 s f → Conv... | The pointwise maximum of convex functions is convex. | true |
Lean.Compiler.LCNF.Check.Pure.State.recOn | Lean.Compiler.LCNF.Check | {motive : Lean.Compiler.LCNF.Check.Pure.State → Sort u} →
(t : Lean.Compiler.LCNF.Check.Pure.State) → ((all : Lean.FVarIdHashSet) → motive { all := all }) → motive t | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.rightDistributor_inv._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
Part.lawfulFix | Mathlib.Control.LawfulFix | {α : Type u_1} → LawfulFix (Part α) | null | true |
leftLim_eq_of_tendsto | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace β] [hα : TopologicalSpace α]
[h'α : OrderTopology α] [T2Space β] {f : α → β} {a : α} {y : β} [h : (nhdsWithin a (Set.Iio a)).NeBot],
Filter.Tendsto f (nhdsWithin a (Set.Iio a)) (nhds y) → Function.leftLim f a = y | null | true |
OrderMonoidHom.inr_apply | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : Monoid α] [inst_1 : PartialOrder α] [inst_2 : Monoid β] [inst_3 : Preorder β]
(y : β), (OrderMonoidHom.inr α β) y = (1, y) | null | true |
CategoryTheory.HomOrthogonal.matrixDecomposition._proof_5 | Mathlib.CategoryTheory.Preadditive.HomOrthogonal | ∀ {C : Type u_1} {ι : Type u_2} {s : ι → C} {α β : Type} {f : α → ι} {g : β → ι} (j : α) (k : β),
f j = g k → s (f j) = s (g k) | null | false |
UpperHalfPlane.coe_injective | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | Function.Injective UpperHalfPlane.coe | null | true |
AddSubmonoid.addUnits._proof_2 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M) {x : AddUnits M},
x ∈ (AddSubmonoid.comap (AddUnits.coeHom M) S ⊓ -AddSubmonoid.comap (AddUnits.coeHom M) S).carrier →
-x ∈ ↑(AddSubmonoid.comap (AddUnits.coeHom M) S) ∧ -x ∈ ↑(-AddSubmonoid.comap (AddUnits.coeHom M) S) | null | false |
Lean.LocalContext.ctorIdx | Lean.LocalContext | Lean.LocalContext → ℕ | null | false |
Vector.foldl_flatten | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {m n : ℕ} {f : β → α → β} {b : β} {xss : Vector (Vector α m) n},
Vector.foldl f b xss.flatten = Vector.foldl (fun b xs => Vector.foldl f b xs) b xss | null | true |
Int.bitwise | Mathlib.Data.Int.Bitwise | (Bool → Bool → Bool) → ℤ → ℤ → ℤ | `Int.bitwise` applies the function `f` to pairs of bits in the same position in
the binary representations of its inputs. | true |
Lean.Grind.Bool.ne_of_eq_false_of_eq_true | Init.Grind.Lemmas | ∀ {a b : Bool}, a = false → b = true → (a = b) = False | null | true |
TopologicalSpace.cofinite._proof_3 | Mathlib.Topology.Constructions | ∀ {X : Type u_1} (s : Set (Set X)), (∀ t ∈ s, t.Nonempty → tᶜ.Finite) → (⋃₀ s).Nonempty → (⋃₀ s)ᶜ.Finite | null | false |
BddLat.mk._flat_ctor | Mathlib.Order.Category.BddLat | (carrier : Type u_1) → [str : Lattice carrier] → [isBoundedOrder : BoundedOrder carrier] → BddLat | null | false |
_private.Mathlib.LinearAlgebra.Finsupp.Supported.0.Finsupp.supported_iInter._simp_1_1 | Mathlib.LinearAlgebra.Finsupp.Supported | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set α} (p : α →₀ M), (p ∈ Finsupp.supported M R s) = (↑p.support ⊆ s) | null | false |
Composition.ne_single_iff | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (hn : 0 < n) {c : Composition n}, c ≠ Composition.single n hn ↔ ∀ (i : Fin c.length), c.blocksFun i < n | null | true |
Lean.Json.num.noConfusion | Lean.Data.Json.Basic | {P : Sort u} → {n n' : Lean.JsonNumber} → Lean.Json.num n = Lean.Json.num n' → (n = n' → P) → P | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt32.zero_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (b ≤ a) = ¬a < b | null | false |
Set.subset_smul_set_iff | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A B : Set β} {a : α}, A ⊆ a • B ↔ a⁻¹ • A ⊆ B | null | true |
Polynomial.normalizedFactors_cyclotomic_card | Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Fintype K] {p f n : ℕ},
Fintype.card K = p ^ f →
∀ (hn : p.Coprime n) [hp : Fact (Nat.Prime p)] [inst_2 : DecidableEq K],
(UniqueFactorizationMonoid.normalizedFactors (Polynomial.cyclotomic n K)).toFinset.card =
n.totient / orderOf (ZMod.unitOfCoprime (p ^... | Let `K` be a finite field of cardinality `p ^ f` and let `P` be an irreducible factor of the
`n`-th cyclotomic polynomial over `K`, where `p` and `n` are coprime. This result computes the
number of distinct irreducible factors of `cyclotomic n K`. | true |
Lean.Parser.ParserCategory.recOn | Lean.Parser.Basic | {motive : Lean.Parser.ParserCategory → Sort u} →
(t : Lean.Parser.ParserCategory) →
((declName : Lean.Name) →
(kinds : Lean.Parser.SyntaxNodeKindSet) →
(tables : Lean.Parser.PrattParsingTables) →
(behavior : Lean.Parser.LeadingIdentBehavior) →
motive { declName := declN... | null | false |
ExpGrowth.expGrowthInf_inv | Mathlib.Analysis.Asymptotics.ExpGrowth | ∀ {u : ℕ → ENNReal}, ExpGrowth.expGrowthInf u⁻¹ = -ExpGrowth.expGrowthSup u | null | true |
Lean.Compiler.LCNF.CollectLevelParams.visitLetValue | Lean.Compiler.LCNF.Level | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Lean.CollectLevelParams.Visitor | null | true |
_private.Mathlib.Tactic.NormNum.Pow.0.Mathlib.Meta.NormNum.evalZPow._proof_1 | Mathlib.Tactic.NormNum.Pow | ∀ {u : Lean.Level} {α : Q(Type u)} (e a : Q(«$α»)) (b : Q(ℤ)) (_c : Q(DivisionSemiring «$α»)), «$e» =Q «$a» ^ «$b» | null | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.UnusedVariables.unusedVariables.match_6 | Lean.Linter.UnusedVariables | (motive : Option Lean.Syntax.Stack → Sort u_1) →
(x : Option Lean.Syntax.Stack) →
((id' : Lean.Syntax) → (snd : ℕ) → (stack : List (Lean.Syntax × ℕ)) → motive (some ((id', snd) :: stack))) →
((x : Option Lean.Syntax.Stack) → motive x) → motive x | null | false |
AlgCat.instAlgebraElemForallObjCompForgetAlgHomCarrierSections._aux_3 | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u_1} →
[inst : CommRing R] →
{J : Type u_2} →
[inst_1 : CategoryTheory.Category.{u_4, u_2} J] →
(F : CategoryTheory.Functor J (AlgCat R)) → R →+* ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections | null | false |
TemperedDistribution.MemSobolev.sub | Mathlib.Analysis.Distribution.Sobolev | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : NormedSpace ℂ F] [inst_7 : CompleteSpace F] {s : ℝ} {p : ENNReal} [hp : Fact (1 ≤ p)]
{f g ... | null | true |
Lean.Elab.Term.FunBinders.State.expectedType? | Lean.Elab.Binders | Lean.Elab.Term.FunBinders.State → Option Lean.Expr | null | true |
AddSubgroup.mem_closure | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] {k : Set G} {x : G},
x ∈ AddSubgroup.closure k ↔ ∀ (K : AddSubgroup G), k ⊆ ↑K → x ∈ K | null | true |
SSet.relativeCellComplex._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ (X : SSet), CategoryTheory.Mono ⊥.ι | null | false |
Mathlib.Tactic.LinearCombination.Expanded.ctorElimType | Mathlib.Tactic.LinearCombination | {motive : Mathlib.Tactic.LinearCombination.Expanded → Sort u} → ℕ → Sort (max 1 u) | null | false |
HasStrictDerivAt.div | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'} {c' d' : 𝕜'},
HasStrictDerivAt c c' x →
HasStrictDerivAt d d' x → d x ≠ 0 → HasStrictDerivAt (c / d) ((c' * d x - c x * d') / d x ^ 2) x | null | true |
Std.IterM.forIn_mapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {n : Type u_1 → Type u_3} {o : Type u_1 → Type u_4} {α β β₂ γ : Type u_1} [inst : Monad m]
[LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n] [inst_4 : Monad o] [LawfulMonad o] [inst_6 : MonadAttach n]
[WeaklyLawfulMonadAttach n] [inst_8 : MonadLiftT m n] [LawfulMonadLiftT m n] [inst_10 ... | null | true |
SimpleGraph.IsHamiltonian.mono | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} [inst_1 : Fintype α] {H : SimpleGraph α},
G ≤ H → G.IsHamiltonian → H.IsHamiltonian | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.