name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matrix.IsStrictlyPositive.posDef | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {x : Matrix n n 𝕜},
IsStrictlyPositive x → x.PosDef | **Alias** of the forward direction of `Matrix.isStrictlyPositive_iff_posDef`. | true |
CategoryTheory.GrothendieckTopology.OneHypercover.recOn | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{S : C} →
{motive : J.OneHypercover S → Sort u_1} →
(t : J.OneHypercover S) →
((toPreOneHypercover : CategoryTheory.PreOneHypercover S) →
(mem₀ : toPreOneHyp... | null | false |
CategoryTheory.Limits.Types.Image.ι | Mathlib.CategoryTheory.Limits.Types.Images | {α β : Type u} → (f : α ⟶ β) → CategoryTheory.Limits.Types.Image f ⟶ β | the inclusion of `Image f` into the target | true |
_private.Mathlib.MeasureTheory.Covering.Vitali.0.Vitali.exists_disjoint_covering_ae'._proof_1_1 | Mathlib.MeasureTheory.Covering.Vitali | (2 + 1).AtLeastTwo | null | false |
WeierstrassCurve.natDegree_Ψ₂Sq_le | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R), W.Ψ₂Sq.natDegree ≤ 3 | null | true |
Prod.seminormedRing._proof_14 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedRing α] [inst_1 : SeminormedRing β] (a : α × β),
SubNegMonoid.zsmul 0 a = 0 | null | false |
FundamentalGroupoidFunctor.prodToProdTop | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | (A : TopCat) →
(B : TopCat) →
CategoryTheory.Functor
(↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B))
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj (TopCat.of (↑A × ↑B))) | The map taking the product of two fundamental groupoids to the fundamental groupoid of the product
of the two topological spaces. This is in fact an isomorphism (see `prodIso`).
| true |
BitVec.clzAuxRec._unsafe_rec | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → ℕ → BitVec w | null | false |
ProofWidgets.MarkdownDisplay.Props.mk._flat_ctor | ProofWidgets.Component.Basic | String → ProofWidgets.MarkdownDisplay.Props | null | false |
Complex.log_mul_ofReal | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ (r : ℝ), 0 < r → ∀ (x : ℂ), x ≠ 0 → Complex.log (x * ↑r) = ↑(Real.log r) + Complex.log x | null | true |
CategoryTheory.TwoSquare.GuitartExact.quotient_of_nonempty_leftHomotopy | Mathlib.CategoryTheory.GuitartExact.Quotient | ∀ {C₀ : Type u_1} {C : Type u_2} {H₀ : Type u_3} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₀]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Category.{v_3, u_3} H₀]
[inst_3 : CategoryTheory.Category.{v_4, u_4} H] {T : CategoryTheory.Functor C₀ H₀} {L : CategoryTheory.Funct... | null | true |
Set.instIrreflSSubset | Mathlib.Data.Set.Basic | ∀ {α : Type u}, Std.Irrefl fun x1 x2 => x1 ⊂ x2 | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.fastUmulOverflow._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ (x : BitVec (0 + 1)), ¬x.toNat ≤ 1 → False | null | false |
Lean.Elab.Do.observingPostpone | Lean.Elab.Do.Basic | {α : Type} → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM (Option α) | null | true |
CategoryTheory.Limits.HasImageMaps.has_image_map | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasImages C}
[self : CategoryTheory.Limits.HasImageMaps C] {f g : CategoryTheory.Arrow C} (st : f ⟶ g),
CategoryTheory.Limits.HasImageMap st | null | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Entails.0.Lean.Elab.Tactic.Do.Internal.VCGen.neededStateIntro._sparseCasesOn_4 | Lean.Elab.Tactic.Do.Internal.VCGen.Entails | {motive : Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind → Sort u} →
(t : Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind) →
((etaPotential : ℕ) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind.triple etaPotential)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
AlgebraicGeometry.geometrically_iff_of_commRing_of_isClosedUnderIsomorphisms | Mathlib.AlgebraicGeometry.Geometrically.Basic | ∀ {X : AlgebraicGeometry.Scheme} {P : CategoryTheory.ObjectProperty AlgebraicGeometry.Scheme} {R : Type u}
[inst : CommRing R] {f : X ⟶ AlgebraicGeometry.Spec (CommRingCat.of R)} [P.IsClosedUnderIsomorphisms],
AlgebraicGeometry.geometrically P f ↔
∀ (K : Type u) [inst_2 : Field K] [inst_3 : Algebra R K],
... | null | true |
QuotientAddGroup.addEquivPiModRangeNSMulAddMonoidHom._proof_7 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {ι : Type u_2} (A : ι → Type u_1) [inst : (i : ι) → AddCommGroup (A i)] (n : ℕ)
(y : (i : ι) → A i ⧸ (nsmulAddMonoidHom n).range),
∃ a, { toFun := fun x x_1 => ↑(x x_1), map_zero' := ⋯, map_add' := ⋯ } a = y | null | false |
TensorProduct.addCommGroup._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
SMulCommClass R ℤ M | null | false |
Tactic.NormNum.NotPowerCertificate.pf_left | Mathlib.Tactic.NormNum.Irrational | {m n : Q(ℕ)} → (self : Tactic.NormNum.NotPowerCertificate m n) → Q(unknown_1 ^ «$n» < «$m») | Proof of `k ^ n < m`. | true |
IncidenceAlgebra.coe_add._simp_1 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : AddZeroClass 𝕜] [inst_1 : LE α] (f g : IncidenceAlgebra 𝕜 α), ⇑f + ⇑g = ⇑(f + g) | null | false |
CategoryTheory.CommGrp.forget_obj | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.CommGrp C),
(CategoryTheory.CommGrp.forget C).obj X = X.X | null | true |
AlgebraicGeometry.Scheme.Hom.resLE_appLE | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U : Y.Opens} {V : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (O : (↑U).Opens) (W : (↑V).Opens)
(e' : W ≤ (TopologicalSpace.Opens.map (AlgebraicGeometry.Scheme.Hom.resLE f U V e).base).obj O),
AlgebraicGeometry.Scheme.Hom.appLE (AlgebraicGeometry.Sc... | null | true |
Lean.NamePart.num.noConfusion | Lean.Data.NameTrie | {P : Sort u} → {n n' : ℕ} → Lean.NamePart.num n = Lean.NamePart.num n' → (n = n' → P) → P | null | false |
CategoryTheory.Sieve.pushforward_monotone | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X),
Monotone (CategoryTheory.Sieve.pushforward f) | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal.mk.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
(toDiagram : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ) (top : J)
(isTerminal isTerminal_1 : toDiagram.IsTerminal top),
isTerminal = isTerminal_1 →
∀ (uniq_terminal : ∀ (j : J) (hj : toDiagram.IsTerminal j),... | null | true |
normEDSRec._proof_5 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ (x : ℕ), x + 5 < 2 * (x + 3) | null | false |
QuotientGroup.Quotient.group._proof_8 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal],
autoParam (∀ (a b : G ⧸ N), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam | null | false |
Group.exponent_dvd_iff_forall_zpow_eq_one | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : Group G] {n : ℤ}, ↑(Monoid.exponent G) ∣ n ↔ ∀ (g : G), g ^ n = 1 | null | true |
_private.Lean.Meta.Sym.AlphaShareBuilder.0.Lean.Expr.updateLambdaS!.match_1 | Lean.Meta.Sym.AlphaShareBuilder | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam n d b bi)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
affineCombination_mem_affineSpan | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {ι : Type u_1} {k : Type u_2} {V : Type u_3} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V]
[inst_2 : Module k V] [inst_3 : AddTorsor V P] [Nontrivial k] {s : Finset ι} {w : ι → k},
∑ i ∈ s, w i = 1 → ∀ (p : ι → P), (Finset.affineCombination k s p) w ∈ affineSpan k (Set.range p) | An `affineCombination` with sum of weights 1 is in the
`affineSpan` of an indexed family, if the underlying ring is
nontrivial. | true |
le_gauge_of_subset_closedBall | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E} {r : ℝ} {x : E},
Absorbent ℝ s → 0 ≤ r → s ⊆ Metric.closedBall 0 r → ‖x‖ / r ≤ gauge s x | null | true |
CochainComplex.mappingCocone.liftCochain.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
{n m : ℤ} (α α_1 : CochainComplex.HomComplex.Cochain M K n),
α = α_1 →
∀ (β β_1 : CochainCom... | null | true |
MonoidAlgebra.comapDomainAddMonoidHom._proof_2 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Semiring R] (f : M → N) (hf : Function.Injective f),
MonoidAlgebra.comapDomain f hf 0 = 0 | null | false |
_private.Mathlib.Combinatorics.Enumerative.Partition.GenFun.0.Nat.Partition.aux_dvd_of_coeff_ne_zero | Mathlib.Combinatorics.Enumerative.Partition.GenFun | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace R] [T2Space R] {f : ℕ → ℕ → R} {d : ℕ}
{s : Finset ℕ},
0 ∉ s →
∀ {g : ℕ →₀ ℕ},
g ∈ s.finsuppAntidiag d →
(∀ i ∈ s, (PowerSeries.coeff (g i)) (1 + ∑' (j : ℕ), f i (j + 1) • PowerSeries.X ^ (i * (j + 1))) ≠ 0) →
∀ (x : ℕ),... | null | true |
FirstOrder.Field.FieldAxiom.mulAssoc | Mathlib.ModelTheory.Algebra.Field.Basic | FirstOrder.Field.FieldAxiom | null | true |
convexJoin_singleton_segment | Mathlib.Analysis.Convex.Join | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] (a b c : E),
convexJoin 𝕜 {a} (segment 𝕜 b c) = (convexHull 𝕜) {a, b, c} | null | true |
Option.bind_id_eq_join | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {x : Option (Option α)}, x.bind id = x.join | null | true |
Int16.lt_of_lt_of_le | Init.Data.SInt.Lemmas | ∀ {a b c : Int16}, a < b → b ≤ c → a < c | null | true |
Vector.setIfInBounds_setIfInBounds | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} (a : α) {b : α} {xs : Vector α n},
(xs.setIfInBounds i a).setIfInBounds i b = xs.setIfInBounds i b | null | true |
instLatticeSubtypeIsIdempotentElem._proof_10 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommRing R] (a b c : { a // IsIdempotentElem a }), a ≤ b → a ≤ c → a ≤ SemilatticeInf.inf b c | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionRight_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (c : C) {d d' : D} (f : d ⟶ d'),
CategoryTheory.MonoidalCategory.MonoidalLeft... | null | true |
CategoryTheory.Functor.FullyFaithful.ofFullyFaithful | Mathlib.CategoryTheory.Functor.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → [F.Full] → [F.Faithful] → F.FullyFaithful | A `FullyFaithful` structure can be obtained from the assumption the `F` is both
full and faithful. | true |
Real.logb_zero_left_eq_zero | Mathlib.Analysis.SpecialFunctions.Log.Base | Real.logb 0 = 0 | null | true |
Lean.Meta.Grind.EMatchTheoremConstraint.guard.inj | Lean.Meta.Tactic.Grind.Extension | ∀ {e e_1 : Lean.Expr},
Lean.Meta.Grind.EMatchTheoremConstraint.guard e = Lean.Meta.Grind.EMatchTheoremConstraint.guard e_1 → e = e_1 | null | true |
Int.Linear.eq_coeff | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p p' : Int.Linear.Poly) (k : ℤ),
Int.Linear.eq_coeff_cert p p' k = true → Int.Linear.Poly.denote' ctx p = 0 → Int.Linear.Poly.denote' ctx p' = 0 | null | true |
TwoP.concreteCategory._proof_6 | Mathlib.CategoryTheory.Category.TwoP | autoParam (∀ {X Y : TwoP} (f : X ⟶ Y), TwoP.concreteCategory._aux_3 (TwoP.concreteCategory._aux_1 f) = f)
CategoryTheory.ConcreteCategory.ofHom_hom._autoParam | null | false |
AlgebraicGeometry.Scheme.smallEtaleTopology | Mathlib.AlgebraicGeometry.Sites.Etale | (X : AlgebraicGeometry.Scheme) → CategoryTheory.GrothendieckTopology X.Etale | The small étale site of a scheme is the Grothendieck topology on the
category of schemes étale over `X` induced from the étale topology on `Scheme.{u}`. | true |
Prod.gameAdd_mk_iff | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {β : Type u_2} {rα : α → α → Prop} {rβ : β → β → Prop} {a₁ a₂ : α} {b₁ b₂ : β},
Prod.GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ rα a₁ a₂ ∧ b₁ = b₂ ∨ rβ b₁ b₂ ∧ a₁ = a₂ | null | true |
Fin.instCommRing._proof_11 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) [inst : NeZero n] (a b c : Fin n), (a + b) * c = a * c + b * c | null | false |
LinearMap.IsSymmetric.id._simp_1 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
LinearMap.id.IsSymmetric = True | null | false |
Int.add_le_of_le_neg_add | Init.Data.Int.Order | ∀ {a b c : ℤ}, b ≤ -a + c → a + b ≤ c | null | true |
_private.Mathlib.Topology.Order.LiminfLimsup.0.tendsto_iSup_of_tendsto_limsup._simp_1_2 | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
_private.Mathlib.Algebra.FreeMonoid.FreeSemigroup.0.FreeSemigroup.range_toFreeMonoid._proof_1_1 | Mathlib.Algebra.FreeMonoid.FreeSemigroup | ∀ {α : Type u_1} (x : FreeMonoid α), x ∈ Set.range ⇑FreeSemigroup.toFreeMonoid ↔ x ∈ {1}ᶜ | null | false |
SimplicialObject.opEquivalence._proof_2 | Mathlib.AlgebraicTopology.SimplicialObject.Op | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : CategoryTheory.SimplicialObject C),
CategoryTheory.CategoryStruct.comp
(SimplicialObject.opFunctor.map (SimplicialObject.opFunctorCompOpFunctorIso.symm.hom.app X))
(SimplicialObject.opFunctorCompOpFunctorIso.hom.app (SimplicialObject.opFu... | null | false |
CategoryTheory.Functor.LaxBraided.ofNatIso | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_4 : CategoryTheory.MonoidalCategory D] →
... | Given two lax monoidal, monoidally isomorphic functors, if one is lax braided, so is the other.
| true |
FormalMultilinearSeries.compContinuousLinearMap | Mathlib.Analysis.Calculus.FormalMultilinearSeries | {𝕜 : Type u} →
{E : Type v} →
{F : Type w} →
{G : Type x} →
[inst : Semiring 𝕜] →
[inst_1 : AddCommMonoid E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : ContinuousAdd E] →
[inst_5 : ContinuousConstSMul �... | Composing each term `pₙ` in a formal multilinear series with `(u, ..., u)` where `u` is a fixed
continuous linear map, gives a new formal multilinear series `p.compContinuousLinearMap u`. | true |
RingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J RingCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget RingCat)).sections] →
CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ RingCat SemiRingCat) | We show that the forgetful functor `CommRingCat ⥤ RingCat` creates limits.
All we need to do is notice that the limit point has a `Ring` instance available,
and then reuse the existing limit.
| true |
CategoryTheory.Limits.limit.isLimitToOver | Mathlib.CategoryTheory.Limits.Over | {J : Type w} →
[inst : CategoryTheory.Category.{w', w} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasLimit F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.toUnder F) | If `F` has a limit, then the cone `limit.toUnder F` with cone point `𝟙 (limit F)` is
also a limit cone. | true |
Lean.Language.SnapshotTree.foldSnaps.Control.proceed.noConfusion | Lean.Server.Requests | {P : Sort u} →
{foldChildren foldChildren' : Bool} →
Lean.Language.SnapshotTree.foldSnaps.Control.proceed foldChildren =
Lean.Language.SnapshotTree.foldSnaps.Control.proceed foldChildren' →
(foldChildren = foldChildren' → P) → P | null | false |
PSet.Subset | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop | A pre-set is a subset of another pre-set if every element of the first family is extensionally
equivalent to some element of the second family. | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Beta.0.Complex.betaIntegral_symm._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Gamma.Beta | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
(a b : ℝ), -∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ) in b..a, f x ∂μ | null | false |
CStarAlgebra.mk | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
[toNormedRing : NormedRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedAlgebra : NormedAlgebra ℂ A] → [toStarModule : StarModule ℂ A] → CStarAlgebra A | null | true |
mabs_div_le_max_div | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b c : G},
a ≤ b → b ≤ c → ∀ (d : G), |b / d|ₘ ≤ max (c / d) (d / a) | null | true |
RatFunc.CompletionAtInfty.instField._proof_27 | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (a b c : RatFunc.CompletionAtInfty F),
(a + b) * c = a * c + b * c | null | false |
Finsupp.weight_single_one_apply | Mathlib.Data.Finsupp.Weight | ∀ {σ : Type u_1} {R : Type u_3} [inst : Semiring R] [inst_1 : DecidableEq σ] (s : σ) (f : σ →₀ R),
(Finsupp.weight (Pi.single s 1)) f = f s | null | true |
Nat.instConditionallyCompleteLinearOrderBot | Mathlib.Order.Lattice.Nat | ConditionallyCompleteLinearOrderBot ℕ | null | true |
Lean.TSyntax.instCoeNumLitPrec | Init.Meta.Defs | Coe Lean.NumLit Lean.Prec | null | true |
forall_and_left | Mathlib.Logic.Basic | ∀ {α : Sort u_1} [Nonempty α] (q : Prop) (p : α → Prop), (∀ (x : α), q ∧ p x) ↔ q ∧ ∀ (x : α), p x | null | true |
Pi.measurableMul | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {ι : Type u_5} {α : ι → Type u_6} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → MeasurableSpace (α i)]
[∀ (i : ι), MeasurableMul (α i)], MeasurableMul ((i : ι) → α i) | null | true |
FP.Float.nan | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float | null | true |
DFinsupp.filter_eq' | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (f : Π₀ (i : ι), β i) (i : ι),
DFinsupp.filter (fun x => x = i) f = fun₀ | i => f i | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.termρᵣ | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.ParserDescr | Notation for `actionUnitIso`, the structural isomorphism `- ⊙ᵣ 𝟙_ C ≅ -`. | true |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.elabLinearCombination.match_3 | Mathlib.Tactic.LinearCombination | (motive : Option Lean.Term → Sort u_1) →
(input : Option Lean.Term) → (Unit → motive none) → ((e : Lean.Term) → motive (some e)) → motive input | null | false |
Array.any_eq_true' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.any p = true ↔ ∃ x ∈ as, p x = true | Variant of `any_eq_true` in terms of membership rather than an array index. | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.le_posLE_iff._simp_1_2 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
Subalgebra.perfectClosure._proof_2 | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (p : ℕ)
[ExpChar A p] {a b : A},
a ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} →
b ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} → a + b ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} | null | false |
instWellFoundedLTOrderDualOfWellFoundedGT | Mathlib.Order.RelClasses | ∀ (α : Type u_1) [inst : LT α] [h : WellFoundedGT α], WellFoundedLT αᵒᵈ | null | true |
Std.IteratorAccess.ctorIdx | Init.Data.Iterators.Consumers.Monadic.Access | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → {inst : Std.Iterator α m β} → Std.IteratorAccess α m → ℕ | null | false |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.basisDivisor_inj._simp_1_6 | Mathlib.LinearAlgebra.Lagrange | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
ContinuousMap.linearIsometryBoundedOfCompact_apply_apply | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] {𝕜 : Type u_4} [inst_3 : NormedRing 𝕜] [inst_4 : Module 𝕜 E]
[inst_5 : IsBoundedSMul 𝕜 E] (f : C(α, E)) (a : α), ((ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜) f) a = f a | null | true |
ContinuousLinearMap.isInvertible_comp_equiv._simp_1 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} {M₃ : Type u_4} [inst : TopologicalSpace M]
[inst_1 : TopologicalSpace M₂] [inst_2 : TopologicalSpace M₃] [inst_3 : Semiring R] [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid M₂] [inst_7 : Module R M₂] [inst_8 : AddCommMonoid M₃]
[inst_9 : ... | null | false |
LinearMap.mkContinuous_norm_le | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ₁₂] F) {C : ℝ},
... | If a continuous linear map is constructed from a linear map via the constructor `mkContinuous`,
then its norm is bounded by the bound given to the constructor if it is nonnegative. | true |
Lean.TheoremVal.mk._flat_ctor | Lean.Declaration | Lean.Name → List Lean.Name → Lean.Expr → Lean.Expr → List Lean.Name → Lean.TheoremVal | null | false |
Aesop.Frontend.Feature.ctorElim | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.Feature → Sort u} →
(ctorIdx : ℕ) →
(t : Aesop.Frontend.Feature) → ctorIdx = t.ctorIdx → Aesop.Frontend.Feature.ctorElimType ctorIdx → motive t | null | false |
SuccOrder.prelimitRecOn._proof_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] (a : α),
¬Order.IsSuccPrelimit a → ∃ b, ¬IsMax b ∧ Order.succ b = a | null | false |
AlternativeMonad.map._inherited_default | Batteries.Control.AlternativeMonad | {m : Type u_1 → Type u_2} →
({α : Type u_1} → α → m α) → ({α β : Type u_1} → m α → (α → m β) → m β) → {α β : Type u_1} → (α → β) → m α → m β | null | false |
Ideal.Filtration.Stable.exists_pow_smul_eq | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R}
{F : I.Filtration M}, F.Stable → ∃ n₀, ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀ | null | true |
Lean.Meta.DiscrTree.casesOn | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive : Lean.Meta.DiscrTree α → Sort u} →
(t : Lean.Meta.DiscrTree α) →
((root : Lean.PersistentHashMap Lean.Meta.DiscrTree.Key (Lean.Meta.DiscrTree.Trie α)) → motive { root := root }) →
motive t | null | false |
Set.prod_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] (s : Set α) (t : Set β) (n : ℕ),
s ×ˢ t ^ n = (s ^ n) ×ˢ (t ^ n) | null | true |
MeasureTheory.Measure.measure_support_eq_zero_iff._auto_1 | Mathlib.MeasureTheory.Measure.MeasureSpace | Lean.Syntax | null | false |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremNew.priority | Lean.Elab.Tactic.Do.Internal.VCGen.SpecDB | Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremNew → ℕ | null | true |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.chaar_sup_le._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ici b) = (b ≤ x) | null | false |
_private.Mathlib.Data.ENNReal.Real.0.Mathlib.Meta.Positivity.evalENNRealOfReal.match_1 | Mathlib.Data.ENNReal.Real | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) → Sort u_1) →
... | null | false |
Set.Finite.encard_lt_card | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, s.Finite → s ≠ Set.univ → s.encard < ENat.card α | null | true |
_private.Mathlib.NumberTheory.Primorial.0.primorial_add._proof_1_3 | Mathlib.NumberTheory.Primorial | ∀ (m n : ℕ), m + 1 ≤ m + n + 1 | null | false |
Lean.Grind.Config.splitImp._default | Init.Grind.Config | Bool | null | false |
Complex.mul_cpow_ofReal_nonneg | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ {a b : ℝ}, 0 ≤ a → 0 ≤ b → ∀ (r : ℂ), (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r | null | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mon_mul_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C (CategoryTheory.CommMon D)) (X : C),
CategoryTheory.MonObj.mul.app X = Cate... | null | true |
CategoryTheory.ProjectiveResolution.complex_d_comp_π_f_zero | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z),
CategoryTheory.CategoryStruct.comp (P.complex.d 1 0) (P.π.f 0) = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.