name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SSet.prodStdSimplex.nonDegenerate_max_dim_iff._auto_1 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | Lean.Syntax | null | false |
Lean.Lsp.instToJsonSemanticTokensParams | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.SemanticTokensParams | null | true |
ContinuousLinearMap.apply.congr_simp | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) {E' : Type u_6} (Fₗ' : Type u_11) [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E']
[inst_2 : Module 𝕜 E'] [inst_3 : TopologicalSpace E'] [inst_4 : AddCommGroup Fₗ'] [inst_5 : Module 𝕜 Fₗ']
[inst_6 : TopologicalSpace Fₗ'] [inst_7 : IsNormableSpace 𝕜 Fₗ'] [inst_8 : IsNormableSpace �... | null | true |
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.comp_eq_right_iff._simp_1_5 | Mathlib.LinearAlgebra.Projection | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) | null | false |
SFinKer.deterministic_id_map | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X Y : SFinKer) (f : X.carrier → Y.carrier),
Measurable f → CategoryTheory.Deterministic { hom := ProbabilityTheory.Kernel.id.map f, property := ⋯ } | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.psi_sub_theta_bounds._proof_1_21 | Mathlib.NumberTheory.Chebyshev | ∀ (N₁ N₂ N₃ N₅ N₇ n : ℕ), 1 ≤ n ∧ n ≤ N₁ + N₂ + N₃ + N₅ + N₇ → 7 * n ∈ Set.Ici 1 | null | false |
AlgebraicIndependent.aevalEquivField._proof_13 | Mathlib.RingTheory.AlgebraicIndependent.Adjoin | ∀ {ι : Type u_3} {F : Type u_2} {E : Type u_1} {x : ι → E} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
(hx : AlgebraicIndependent F x), (IsFractionRing.liftAlgHom ⋯).fieldRange = IntermediateField.adjoin F (Set.range x) | null | false |
Lean.Compiler.LCNF.MonadScope.mk | Lean.Compiler.LCNF.MonadScope | {m : Type → Type} →
m Lean.Compiler.LCNF.Scope →
({α : Type} → (Lean.Compiler.LCNF.Scope → Lean.Compiler.LCNF.Scope) → m α → m α) → Lean.Compiler.LCNF.MonadScope m | null | true |
Nat.pow_le_pow_left._f | Init.Data.Nat.Basic | ∀ {n m : ℕ}, n ≤ m → ∀ (x : ℕ) (f : Nat.below x), n ^ x ≤ m ^ x | null | false |
Mathlib.Tactic.Push.instBEqHead.beq | Mathlib.Tactic.Push.Attr | Mathlib.Tactic.Push.Head → Mathlib.Tactic.Push.Head → Bool | null | true |
CategoryTheory.SimplicialObject.cechNerveEquiv._proof_2 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C),
Function.RightInverse (Category... | null | false |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.withRecApps.loop._unsafe_rec | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} →
(recFnName : Lean.Name) →
ℕ → (Lean.Expr → Array Lean.Expr → Lean.MetaM α) → Lean.Expr → Lean.Expr → Lean.Elab.WF.GuessLex.M recFnName α Unit | null | false |
Real.sSup_smul_of_nonneg | Mathlib.Basic.Real.Pointwise | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : MulActionWithZero α ℝ]
[IsOrderedModule α ℝ] {a : α}, 0 ≤ a → ∀ (s : Set ℝ), sSup (a • s) = a • sSup s | null | true |
cfcₙ_complex_eq_real._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | Lean.Syntax | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.Complex.cot_eq_exp_ratio._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
ConvexOn.convex_le | 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 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
[PosSMulMono 𝕜 β] {s : Set E} {f : E → β}, ConvexOn 𝕜 s f → ∀ (r : β), ... | null | true |
Vector.foldr_add_const | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {a b : ℕ}, Vector.foldr (fun x x_1 => x_1 + a) b xs = b + a * n | null | true |
sSupHom.symm_dual_comp | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SupSet α] [inst_1 : SupSet β] [inst_2 : SupSet γ]
(g : sInfHom βᵒᵈ γᵒᵈ) (f : sInfHom αᵒᵈ βᵒᵈ),
sSupHom.dual.symm (g.comp f) = (sSupHom.dual.symm g).comp (sSupHom.dual.symm f) | null | true |
List.interleave_flatten_flatten_of_length_eq_length._f | Batteries.Data.List.Interleave | ∀ {α : Type u_1} (x : List (List α))
(f :
List.below (motive := fun x =>
∀ (x_1 : List (List α)) (x_2 : x.length = x_1.length),
(∀ (i : ℕ) (hi : i + 1 < x.length), x[i].length = x_1[i].length) →
x.flatten.interleave x_1.flatten = (List.zipWith List.interleave x x_1).flatten)
x)
(x_... | null | false |
AddLocalization.r_eq_r' | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M), AddLocalization.r S = AddLocalization.r' S | The additive congruence relation used to localize an `AddCommMonoid` at a submonoid can be
expressed equivalently as an infimum (see `AddLocalization.r`) or explicitly
(see `AddLocalization.r'`). | true |
Nat.instNeZeroSucc | Init.Data.Nat.Basic | ∀ {n : ℕ}, NeZero (n + 1) | null | true |
ProbabilityTheory.exponentialPDF | Mathlib.Probability.Distributions.Exponential | ℝ → ℝ → ENNReal | The pdf of the exponential distribution, as a function valued in `ℝ≥0∞` | true |
Nat.primeFactors_pow | Mathlib.Data.Nat.PrimeFin | ∀ {k : ℕ} (n : ℕ), k ≠ 0 → (n ^ k).primeFactors = n.primeFactors | null | true |
Fin2.noConfusionType | Mathlib.Data.Fin.Fin2 | Sort u → {a : ℕ} → Fin2 a → {a' : ℕ} → Fin2 a' → Sort u | null | false |
Mathlib.Tactic.AddGroup._zsmul_neg_trick | Mathlib.Tactic.AddGroup | ∀ {G : Type u_1} [inst : AddGroup G] (b : G) (n : ℤ), n • b + -b = (n + -1) • b | null | false |
Lean.Meta.Origin.decl.noConfusion | Lean.Meta.Tactic.Simp.SimpTheorems | {P : Sort u} →
{declName : Lean.Name} →
{post : optParam Bool true} →
{inv : optParam Bool false} →
{declName' : Lean.Name} →
{post' : optParam Bool true} →
{inv' : optParam Bool false} →
Lean.Meta.Origin.decl declName post inv = Lean.Meta.Origin.decl declName' po... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastUdivOutput.mk | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} →
{w : ℕ} →
(aig : Std.Sat.AIG α) →
aig.RefVec w →
aig.RefVec w →
old.decls.size ≤ aig.decls.size → Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastUdivOutput ol... | null | true |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.supOfBasis | Mathlib.NumberTheory.NumberField.House | (K : Type u_1) → [inst : Field K] → [NumberField K] → ℝ | `supOfBasis K` calculates the supremum of the absolute values of
the elements in `newBasis K`. | true |
String.Slice.trimAscii | Init.Data.String.Slice | String.Slice → String.Slice | Removes leading and trailing whitespace from a slice.
“Whitespace” is defined as characters for which `Char.isWhitespace` returns `true`.
Examples:
* `"abc".toSlice.trimAscii == "abc".toSlice`
* `" abc".toSlice.trimAscii == "abc".toSlice`
* `"abc \t ".toSlice.trimAscii == "abc".toSlice`
* `" abc ".toSlice.t... | true |
PSet.Lift.match_1 | Mathlib.SetTheory.ZFC.PSet | (α : Type u_2) →
(motive : ULift.{u_1, u_2} α → Sort u_3) → (x : ULift.{u_1, u_2} α) → ((x : α) → motive { down := x }) → motive x | null | false |
lowerSemicontinuousWithinAt_sum | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {x : α} {ι : Type u_4} {γ : Type u_5}
[inst_1 : AddCommMonoid γ] [inst_2 : LinearOrder γ] [IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ]
[OrderTopology γ] [ContinuousAdd γ] {f : ι → α → γ} {a : Finset ι},
(∀ i ∈ a, LowerSemicontinuousWithinAt (f i) s ... | null | true |
ImportGraph.Lake.WorkspaceSummary.cachePath | ImportGraph.WorkspaceModel.Summary.Core | System.FilePath → System.FilePath | Given a special-purpose build folder in the lake directory, the path to
`workspace-summary.json`, where we cache the workspace summary. | true |
Ideal.height_span_le_card_of_span_ne_top | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] {s : Finset R},
Ideal.span ↑s ≠ ⊤ → (Ideal.span ↑s).height ≤ ↑s.card | null | true |
Lean.Syntax.instReprPreresolved | Init.Meta.Defs | Repr Lean.Syntax.Preresolved | null | true |
ModularGroup.coe_S | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ↑ModularGroup.S = !![0, -1; 1, 0] | null | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Mathlib.Meta.Positivity.evalBesicovitchSatelliteConfigR._proof_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q Real.instZero)), «$_zα» =Q Real.instZero | null | false |
CategoryTheory.Functor.natTransEquiv._proof_5 | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F G : CategoryTheory.Functor C D}
(f :
CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C (Type (max u_3 u_2 u_1))) ⟶
F.functorHom G),
(fun f => { app :=... | null | false |
Unitary.coe_neg._simp_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : StarRing R] (U : ↥(unitary R)), -↑U = ↑(-U) | null | false |
IsDiscreteValuationRing.remainder.eq_1 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_2} [inst : CommRing R] (x y : R), IsDiscreteValuationRing.remainder x y = if y ∣ x then 0 else x | null | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic.0.CategoryTheory.Abelian.Ext.comp_assoc._proof_1_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {a₁ a₂ a₃ a : ℕ}, a₁ + a₂ + a₃ = a → ↑a₃ + ↑a₂ + ↑a₁ = ↑a | null | false |
_private.Mathlib.Topology.UniformSpace.UniformApproximation.0.uniformContinuous_of_uniform_approx_of_uniformContinuous._simp_1_1 | Mathlib.Topology.UniformSpace.UniformApproximation | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
UniformContinuousOn f Set.univ = UniformContinuous f | null | false |
StochHom | Mathlib.Probability.Kernel.Category.Stoch | CategoryTheory.MorphismProperty SFinKer | Morphism property selecting Markov kernels in `SFinKer`. | true |
CategoryTheory.yonedaCommRing_map_app_apply | Mathlib.CategoryTheory.Monoidal.Cartesian.Ring | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {R₁ R₂ : CategoryTheory.CommRingObjCat C} (f : R₁ ⟶ R₂) {X : C}
(x : X ⟶ R₁.X),
(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.yonedaCommRing.map f).app... | null | true |
Std.IterM.step_uLift.match_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] →
{it : Std.IterM m β} →
(motive : it.Step → Sort u_3) →
(x : it.Step) →
((it' : Std.IterM m β) →
(out : β) →
(h : it.IsPlausibleStep (S... | null | false |
Matroid.contract_finitary | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {C : Set α} [M.Finitary], (M.contract C).Finitary | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.mk.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{inst : CategoryTheory.Category.{v₁, u₁} A} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} B} →
{inst_2 : CategoryTheory.Category.{v₃, u₃} C} →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
... | null | false |
CategoryTheory.Limits.snd_opProdIsoCoprod_hom | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A B : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct A B],
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd.op (CategoryTheory.Limits.opProdIsoCoprod A B).hom =
CategoryTheory.Limits.coprod.inr | null | true |
Topology.CWComplex.OfDiscreteClosed._proof_16 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} {D : Set X},
⋃ n,
⋃ j,
↑(match n, j with
| 0, i => PartialEquiv.single ![] ↑i
| n.succ, i => PEmpty.elim i) ''
Metric.closedBall 0 1 =
D | null | false |
Lean.PrettyPrinter.Formatter.State.isUngrouped._default | Lean.PrettyPrinter.Formatter | Bool | null | false |
_private.Mathlib.ModelTheory.Syntax.0.FirstOrder.Language.Term.constantsVarsEquiv._simp_2 | Mathlib.ModelTheory.Syntax | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
Polynomial.monomial_sub | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a b : R} [inst : Ring R] (n : ℕ),
(Polynomial.monomial n) (a - b) = (Polynomial.monomial n) a - (Polynomial.monomial n) b | null | true |
SimpleGraph.Walk.IsPath.ne_of_mem_support_of_append | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w},
(p.append q).IsPath → ∀ {x y : V}, y ≠ v → x ∈ p.support → y ∈ q.support → x ≠ y | null | true |
Lean.Meta.Simp.Config.mk.noConfusion | Init.MetaTypes | {P : Sort u} →
{maxSteps maxDischargeDepth : ℕ} →
{contextual memoize singlePass zeta beta eta : Bool} →
{etaStruct : Lean.Meta.EtaStructMode} →
{iota proj decide arith autoUnfold dsimp failIfUnchanged ground unfoldPartialApp zetaDelta index
implicitDefEqProofs zetaUnused catchRuntime ze... | null | false |
_private.Init.Data.String.Lemmas.Pattern.Find.Basic.0.String.Slice.Pattern.Model.find?_eq_none_iff._simp_1_3 | Init.Data.String.Lemmas.Pattern.Find.Basic | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
preNormEDS'_odd | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (b c d : R) (m : ℕ),
preNormEDS' b c d (2 * (m + 2) + 1) =
(preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * if Even m then b else 1) -
preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * if Even m then 1 else b | null | true |
Subring.range_fst | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S], (RingHom.fst R S).rangeS = ⊤ | null | true |
CategoryTheory.Functor.Initial.limitConeOfComp | Mathlib.CategoryTheory.Limits.Final | {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.Initial] →
{E : Type u₃} →
[inst_3 : CategoryTheory.Category.{v₃, u₃} E] →
{G : Cate... | Given a limit cone over `F ⋙ G` we can construct a limit cone over `G`. | true |
RingEquiv.sumArrowEquivProdArrow._proof_1 | Mathlib.Algebra.Ring.Equiv | ∀ (α : Type u_1) (β : Type u_2) (R : Type u_3) [inst : NonAssocSemiring R] (x x_1 : α ⊕ β → R),
(Equiv.sumArrowEquivProdArrow α β R).toFun (x * x_1) = (Equiv.sumArrowEquivProdArrow α β R).toFun (x * x_1) | null | false |
HomotopicalAlgebra.PrepathObject.RightHomotopy.fullSubcategoryEquiv._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.RightHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P : CategoryTheory.ObjectProperty C}
{X Y : P.FullSubcategory} {Q : HomotopicalAlgebra.PrepathObject Y} {f g : X ⟶ Y}
(h : (Q.map P.ι).RightHomotopy f.hom g.hom),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ObjectProperty.homMk h.h) Q.p₀ = f | null | false |
RingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier._proof_2 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J RingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget RingCat)).sections]
(this :
Small.{u_1, max u_1 u_3}
↑((F.comp (CategoryTheory.forget₂ RingCat SemiRingCat)).comp (CategoryTheory.forget ... | null | false |
IsNilpotent.exp_mul_exp_neg_self | Mathlib.RingTheory.Nilpotent.Exp | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : Module ℚ A] {a : A},
IsNilpotent a → IsNilpotent.exp a * IsNilpotent.exp (-a) = 1 | null | true |
_private.Init.Data.Vector.Range.0.Vector.range'_eq_append_iff._simp_1_1 | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {xs ys : Vector α n}, (xs = ys) = (xs.toArray = ys.toArray) | null | false |
_private.Mathlib.Basic.IsEmpty.Basic.0.leftTotal_iff_isEmpty_left._simp_1_3 | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u}, IsEmpty α = ∀ (a : α), False | null | false |
SSet.PtSimplex.MulStruct.op._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(h : f.MulStruct g fg i) {j : Fin n},
i.rev = j →
∀ k < j.castSucc.castSucc,
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ k)
(SSet.yonedaEquiv.symm (SSet.opObjEquiv.symm (SSet.yonedaEquiv ... | null | false |
MeasureTheory.Integrable.of_fst_of_snd_prodLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)},
MeasureTheory.Integrable (fun x => (f x).fst) μ ∧ MeasureTheory.Integrable (fun x =>... | **Alias** of the reverse direction of `MeasureTheory.integrable_prodLp_iff`. | true |
CategoryTheory.Limits.FormalCoproduct.recOn | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | {C : Type u} →
{motive : CategoryTheory.Limits.FormalCoproduct C → Sort u_1} →
(t : CategoryTheory.Limits.FormalCoproduct C) →
((I : Type w) → (obj : I → C) → motive { I := I, obj := obj }) → motive t | null | false |
Prod.continuousAdd | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} {N : Type u_4} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M]
[inst_3 : TopologicalSpace N] [inst_4 : Add N] [ContinuousAdd N], ContinuousAdd (M × N) | null | true |
Array.range'_one | Init.Data.Array.Range | ∀ {s step : ℕ}, Array.range' s 1 step = #[s] | null | true |
Module.Basis.equivFun_apply | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Finite ι] (b : Module.Basis ι R M) (u : M), b.equivFun u = ⇑(b.repr u) | null | true |
_private.Init.Data.List.ToArray.0.List.zipWith_toArray._simp_1_2 | Init.Data.List.ToArray | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : α → β → m γ} {l : List α} {l' : List β}, List.zipWithM f l l' = List.zipWithM' f l l' | null | false |
ContinuousMulEquiv.toHomeomorph_eq_coe | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] (f : M ≃ₜ* N), f.toHomeomorph = ↑f | null | true |
Finset.univ_disjSum_univ | Mathlib.Data.Fintype.Sum | ∀ {α : Type u_3} {β : Type u_4} [inst : Fintype α] [inst_1 : Fintype β], Finset.univ.disjSum Finset.univ = Finset.univ | null | true |
QuadraticAlgebra.norm_zero | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_2} {a b : R} [inst : CommRing R], QuadraticAlgebra.norm 0 = 0 | null | true |
_private.Mathlib.SetTheory.Cardinal.UnivLE.0.univLE_iff_cardinal_le._simp_1_1 | Mathlib.SetTheory.Cardinal.UnivLE | UnivLE.{u, v} = ∀ (α : Type u), Small.{v, u} α | null | false |
ContinuousOn.add_const | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Add M] [SeparatelyContinuousAdd M] {X : Type u_2}
[inst_3 : TopologicalSpace X] {f : X → M} {s : Set X}, ContinuousOn f s → ∀ (b : M), ContinuousOn (fun x => f x + b) s | null | true |
atTop_isCountablyGenerated_of_archimedean | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {R : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Archimedean R],
Filter.atTop.IsCountablyGenerated | null | true |
Std.HashMap.not_mem_emptyWithCapacity | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ}, a ∉ Std.HashMap.emptyWithCapacity c | null | true |
CategoryTheory.Comma.rightIso_inv | Mathlib.CategoryTheory.Comma.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} B] {A : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {R₁ : CategoryTheory.Functor B T}
{L₁ : CategoryTheory.Functor A T} {X Y : CategoryTheory.Comma L₁ R₁} (α : X ≅ Y),
(CategoryTheory.Co... | null | true |
Real.sqrtTwoAddSeries.match_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
Subsemiring.mk.inj | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} {inst : NonAssocSemiring R} {toSubmonoid : Submonoid R}
{add_mem' : ∀ {a b : R}, a ∈ toSubmonoid.carrier → b ∈ toSubmonoid.carrier → a + b ∈ toSubmonoid.carrier}
{zero_mem' : 0 ∈ toSubmonoid.carrier} {toSubmonoid_1 : Submonoid R}
{add_mem'_1 : ∀ {a b : R}, a ∈ toSubmonoid_1.carrier → b ∈ toSubmonoi... | null | true |
Lean.Parser.Command.GrindCnstr.notDefEq.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | null | true |
AddCommMonCat.equivalence_unitIso | Mathlib.Algebra.Category.MonCat.Basic | AddCommMonCat.equivalence.unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id AddCommMonCat) | null | true |
MeasureTheory.integral_one_sub_of_ae_eq_zero_or_one | Mathlib.Probability.Distributions.TwoValued | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
AEMeasurable X μ → (∀ᵐ (ω : Ω) ∂μ, X ω = 0 ∨ X ω = 1) → ∫ (ω : Ω), 1 - X ω ∂μ = μ.real {ω | X ω = 0} | If a random variable is ae equal to `0` or `1`, then one minus its expectation is equal to the
probability that it equals `0`. | true |
Semiquot.ext | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {q₁ q₂ : Semiquot α}, q₁ = q₂ ↔ ∀ (a : α), a ∈ q₁ ↔ a ∈ q₂ | null | true |
AddMonoidHom.fiberEquivKerOfSurjective | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} →
[inst : AddGroup α] →
{H : Type u_2} → [inst_1 : AddGroup H] → {f : α →+ H} → Function.Surjective ⇑f → (h : H) → ↑(⇑f ⁻¹' {h}) ≃ ↥f.ker | An equivalence between any fiber of a surjective `AddMonoidHom` and its kernel. | true |
List.cyclicPermutations_eq_singleton_iff._simp_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u} {l : List α} {x : α}, (l.cyclicPermutations = [[x]]) = (l = [x]) | null | false |
Std.Http.Header.instReprExpect | Std.Http.Data.Headers.Basic | Repr Std.Http.Header.Expect | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastNot | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.RefVec w)
(assign : α → Bool) (idx : ℕ) (hidx : idx < w),
⟦assign,
{ aig := (Std.Tactic.BVDecide.BVExpr.bitblast.blastNot aig target).aig,
ref := (Std.Tactic.BVDecide.BVExpr.bitblast.blastNot aig targ... | null | true |
Int.dvd_self_sub_tmod | Init.Data.Int.DivMod.Lemmas | ∀ {x m : ℤ}, m ∣ x - x.tmod m | null | true |
GenContFract.le_of_succ_succ_get?_contsAux_b | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K] {b : K},
(GenContFract.of v).partDens.get? n = some b →
b * ((GenContFract.of v).contsAux (n + 1)).b ≤ ((GenContFract.of v).contsAux (n + 2)).b | null | true |
Mathlib.Meta.NormNum.IsRat.den_nz | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : DivisionRing α] {a : α} {n : ℤ} {d : ℕ}, Mathlib.Meta.NormNum.IsRat a n d → ↑d ≠ 0 | null | true |
isClosedMap_smul_left | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : TopologicalSpace E] [IsTopologicalAddGroup E] [inst_5 : Module 𝕜 E] [ContinuousSMul 𝕜 E] [T2Space E]
(c : E), IsClosedMap fun x => x • c | null | true |
Mathlib.Tactic.Abel.term_eq | Mathlib.Tactic.Abel | ∀ {α : Type u_1} [inst : AddCommMonoid α] (n : ℕ) (x a : α), Mathlib.Tactic.Abel.term n x a = n • x + a | null | true |
Mathlib.Tactic.Sat.buildReify.match_1 | Mathlib.Tactic.Sat.FromLRAT | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((e₂ h₂ : Lean.Expr) → motive (e₂, h₂)) → motive x | null | false |
mdifferentiableAt_iff_target_of_mem_source | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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... | null | true |
IsPurelyInseparable.HasExponent | Mathlib.FieldTheory.PurelyInseparable.Exponent | (K : Type u_2) → (L : Type u_3) → [inst : CommRing K] → [inst_1 : Ring L] → [Algebra K L] → Prop | A predicate class on a ring extension saying that there is a natural number `e`
such that `a ^ ringExpChar K ^ e ∈ K` for all `a ∈ L`. | true |
Lean.Compiler.LCNF.FixedParams.State.visited | Lean.Compiler.LCNF.FixedParams | Lean.Compiler.LCNF.FixedParams.State → Std.HashSet (Lean.Name × Array Lean.Compiler.LCNF.FixedParams.AbsValue) | Set of calls that have been already analyzed.
Recall that we assume that only functions in `decls` may have recursive calls to the function being analyzed (i.e., `main`).
Whenever there is function application `f a₁ ... aₙ`, where `f` is in `decls`, `f` is not `main`, and
we visit with the abstract values assigned to `... | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.Corec.f.match_1.splitter | Mathlib.Data.Seq.Computation | {α : Type u_1} →
{β : Type u_2} →
(motive : α ⊕ β → Sort u_3) →
(x : α ⊕ β) → ((a : α) → motive (Sum.inl a)) → ((val : β) → motive (Sum.inr val)) → motive x | null | true |
MeasureTheory.stoppedProcess_eq_of_mem_finset | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} [inst : Nonempty ι] {τ : Ω → WithTop ι} {E : Type u_4} {u : ι → Ω → E}
[inst_1 : LinearOrder ι] [inst_2 : AddCommMonoid E] {s : Finset ι} (n : ι),
(∀ (ω : Ω), τ ω < ↑n → τ ω ∈ WithTop.some '' ↑s) →
MeasureTheory.stoppedProcess u τ n =
{a | ↑n ≤ τ a}.indicator (u n) + ∑ i ∈ ... | null | true |
String.Slice.Pos.prev_eq_posLT._proof_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : s.Pos} {h : p ≠ s.startPos}, 0 < p.offset | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.