name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Aesop.RulePattern.mk | Aesop.RulePattern | Lean.Meta.AbstractMVarsResult → Array (Option ℕ) → Array (Option ℕ) → Array Lean.Meta.DiscrTree.Key → Aesop.RulePattern | null | true |
_private.ImportGraph.Lean.MessageData.0.ImportGraph.Lean.MessageData.bulletList._sparseCasesOn_1 | ImportGraph.Lean.MessageData | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.formatMarkerShort.match_1 | Std.Time.Format.Basic | (motive : Std.Time.HourMarker → Sort u_1) →
(marker : Std.Time.HourMarker) →
(Unit → motive Std.Time.HourMarker.am) → (Unit → motive Std.Time.HourMarker.pm) → motive marker | null | false |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.surjective_π_app_zero_of_surjective_map_aux.match_1_1 | Mathlib.CategoryTheory.Limits.Types.Images | (motive : ℕᵒᵖ → Sort u_1) → (x : ℕᵒᵖ) → ((n : ℕ) → motive (Opposite.op n)) → motive x | null | false |
WeierstrassCurve.toCharTwoJNeZeroNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | {F : Type u_2} → [inst : Field F] → (W : WeierstrassCurve F) → W.a₁ ≠ 0 → WeierstrassCurve.VariableChange F | For a `WeierstrassCurve` defined over a field of characteristic = 2,
there is an explicit change of variables of it to `Y² + XY = X³ + a₂X² + a₆`
(`WeierstrassCurve.IsCharTwoJNeZeroNF`) if its j ≠ 0. | true |
Lean.Meta.CanUnfoldPredicateConfig._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.CanUnfoldPredicateConfig → ℕ | null | false |
UpperHalfPlane.cuspFunction_smul | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f : UpperHalfPlane → ℂ},
ContinuousAt (UpperHalfPlane.cuspFunction h f) 0 →
∀ (a : ℂ), UpperHalfPlane.cuspFunction h (a • f) = a • UpperHalfPlane.cuspFunction h f | null | true |
Nat.psub | Mathlib.Data.Nat.PSub | ℕ → ℕ → Option ℕ | Partial subtraction operation. Returns `psub m n = some k`
if `m = n + k`, otherwise `none`. | true |
_private.Mathlib.NumberTheory.Height.NumberField.0.NumberField.finite_setOfPred_mulHeight₁_le._simp_1_1 | Mathlib.NumberTheory.Height.NumberField | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Quiver.Path.addWeightOfEPs_cons | Mathlib.Combinatorics.Quiver.Path.Weight | ∀ {V : Type u_1} [inst : Quiver V] {R : Type u_2} [inst_1 : AddMonoid R] (w : V → V → R) {a b c : V}
(p : Quiver.Path a b) (e : b ⟶ c), Quiver.Path.addWeightOfEPs w (p.cons e) = Quiver.Path.addWeightOfEPs w p + w b c | null | true |
PreAbstractSimplicialComplex.instMin | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | (ι : Type u_1) → Min (PreAbstractSimplicialComplex ι) | The complex consisting of only the faces present in both of its arguments. | true |
AffineEquiv.equivLike | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | null | true |
_private.Lean.Elab.Quotation.Precheck.0.Lean.Elab.Term.Quotation.precheck.match_12 | Lean.Elab.Quotation.Precheck | (motive : Option String → Sort u_1) →
(x : Option String) → ((text : String) → motive (some text)) → (Unit → motive none) → motive x | null | false |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.findGoalsAt?.getPositions | Lean.Server.FileWorker.RequestHandling | Lean.Syntax → Option (String.Pos.Raw × String.Pos.Raw × String.Pos.Raw) | null | true |
UpperSet.mem_iInf_iff | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] {a : α} {f : ι → UpperSet α}, a ∈ ⨅ i, f i ↔ ∃ i, a ∈ f i | null | true |
ModularGroup.denom_apply | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g : Matrix.SpecialLinearGroup (Fin 2) ℤ) (z : UpperHalfPlane),
UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) g)) ↑z =
↑(↑g 1 0) * ↑z + ↑(↑g 1 1) | null | true |
Nat.lt.base | Init.Data.Nat.Basic | ∀ (n : ℕ), n < n.succ | null | true |
finprod_apply | Mathlib.Algebra.BigOperators.Finprod | ∀ {N : Type u_6} [inst : CommMonoid N] {α : Type u_7} {ι : Type u_8} {f : ι → α → N},
Function.HasFiniteMulSupport f → ∀ (a : α), (∏ᶠ (i : ι), f i) a = ∏ᶠ (i : ι), f i a | null | true |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.evalSimp._regBuiltin.Lean.Elab.Tactic.evalSimp.declRange_3 | Lean.Elab.Tactic.Simp | IO Unit | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsCycle.neighborSet_toSubgraph_endpoint._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {α : Type u_1} {a b c d : α}, (s(a, b) = s(c, d)) = Sym2.Rel α (a, b) (c, d) | null | false |
MeasureTheory.VectorMeasure.integral_zero_cbm | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (f : X → E) (μ : MeasureTheory.VectorMeasure X F), ∫ᵛ ... | null | true |
Lake.BuildTrace.rec | Lake.Build.Trace | {motive_1 : Lake.BuildTrace → Sort u} →
{motive_2 : Array Lake.BuildTrace → Sort u} →
{motive_3 : List Lake.BuildTrace → Sort u} →
((caption : String) →
(inputs : Array Lake.BuildTrace) →
(hash : Lake.Hash) →
(mtime : Lake.MTime) →
motive_2 inputs → motive... | null | false |
MeasureTheory.weightedSMul_union' | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (s t : Set α),
MeasurableSet t →
μ s ≠ ⊤ →
μ t ≠ ⊤ →
Disjoint s t →
MeasureTheory.weightedSMul μ (s ∪ t) = MeasureTheory.weightedSMul μ s + Measu... | null | true |
AlgebraicGeometry.IsAffine.casesOn | Mathlib.AlgebraicGeometry.AffineScheme | {X : AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.IsAffine X → Sort u} →
(t : AlgebraicGeometry.IsAffine X) → ((affine : CategoryTheory.IsIso X.toSpecΓ) → motive ⋯) → motive t | null | false |
Std.ExtDHashMap.Const.getD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β},
Std.ExtDHashMap.Const.getD (m₁.union m₂) k fallback =
Std.ExtDHashMap.Const.getD m₂ k (Std.ExtDHashMap.Const.getD m₁ k fallback) | null | true |
Filter.prod_mono_right | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : Filter α) {g₁ g₂ : Filter β}, g₁ ≤ g₂ → f ×ˢ g₁ ≤ f ×ˢ g₂ | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_sum._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {α : Type u_1} (s : Finset α) (f : α → ℝ), ∏ x ∈ s, Real.exp (f x) = Real.exp (∑ x ∈ s, f x) | null | false |
ONote.split._sunfold | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote × ℕ | null | false |
Std.Time.PlainDateTime.instHSubDuration | Std.Time.DateTime.PlainDateTime | HSub Std.Time.PlainDateTime Std.Time.PlainDateTime Std.Time.Duration | null | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.entryAtIdx?_eq_getElem?._simp_1_3 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {a b : ℕ}, (compare a b = Ordering.eq) = (a = b) | null | false |
ArchimedeanOrder.of | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} → M ≃ ArchimedeanOrder M | Create a `ArchimedeanOrder` element from the underlying type. | true |
WriterT.uliftable' | Mathlib.Control.ULiftable | {w : Type u_3} →
{w' : Type u_4} →
{m : Type u_3 → Type u_5} →
{m' : Type u_4 → Type u_6} → [ULiftable m m'] → w ≃ w' → ULiftable (WriterT w m) (WriterT w' m') | for specific writer monads, this function helps to create a uliftable instance | true |
ModularFormClass.qExpansion_coeff_unique | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ} {c : ℕ → ℂ},
0 < h →
h ∈ Γ.strictPeriods →
∀ {f : F} [ModularFormClass F Γ k],
(∀ (τ : UpperHalfPlane), HasSum (fun m => c m • Function.Periodic.qParam h ↑τ ^ m) (f τ)) →
∀ (m : ℕ), c m = (Po... | null | true |
USize.ofBitVec.sizeOf_spec | Init.SizeOf | ∀ (toBitVec : BitVec System.Platform.numBits), sizeOf { toBitVec := toBitVec } = 1 + sizeOf toBitVec | null | true |
HasCompactMulSupport.list_prod | Mathlib.Topology.Algebra.Support | ∀ {α : Type u_9} {β : Type u_10} [inst : TopologicalSpace α] [inst_1 : Monoid β] {l : List (α → β)},
(∀ f ∈ l, HasCompactMulSupport f) → HasCompactMulSupport l.prod | null | true |
CommRingCat.instCategory._proof_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y : CommRingCat} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := RingHom.id ↑X }.hom' } = f | null | false |
mul_eq_zero_iff_right | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, b ≠ 0 → (a * b = 0 ↔ a = 0) | null | true |
WithLp.instProdPseudoMetricSpace | Mathlib.Analysis.Normed.Lp.ProdLp | (p : ENNReal) →
(α : Type u_2) →
(β : Type u_3) →
[hp : Fact (1 ≤ p)] → [PseudoMetricSpace α] → [PseudoMetricSpace β] → PseudoMetricSpace (WithLp p (α × β)) | `PseudoMetricSpace` instance on the product of two pseudometric spaces, using the
`L^p` distance, and having as uniformity the product uniformity. | true |
CategoryTheory.Limits.LimitPresentation.changeDiag | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(P : CategoryTheory.Limits.LimitPresentation J X) →
{F : CategoryTheory.Functor J C} → (F ≅ P.diag) → CategoryTheory.Limits.LimitPresentation J X | If `P` is a limit presentation of `X`, it is possible to define another
limit presentation of `X` where `P.diag` is replaced by an isomorphic functor. | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.MulStruct.assocAux._proof_14 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f₀₁ f₁₂ f₂₃ f₀₂ f₁₃ f₀₃ : X.PtSimplex n x} {i : Fin n}
(h₀₂ : f₀₁.MulStruct f₁₂ f₀₂ i) (h₁₃ : f₁₂.MulStruct f₂₃ f₁₃ i) (h : f₀₁.MulStruct f₁₃ f₀₃ i)
(φ : SSet.stdSimplex.obj { len := n + 2 } ⟶ X),
(∀ (j : Fin (n + 3)) (hj : j ≠ i.castSucc.castSucc.succ)... | null | false |
Stream'.Seq.cons_not_terminatedAt_zero._simp_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {x : α} {s : Stream'.Seq α}, (Stream'.Seq.cons x s).TerminatedAt 0 = False | null | false |
Denumerable | Mathlib.Basic.Denumerable | Type u_3 → Type u_3 | A denumerable type is (constructively) bijective with `ℕ`. Typeclass equivalent of `α ≃ ℕ`. | true |
BitVec.toInt_sshiftRight' | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, (x.sshiftRight' y).toInt = x.toInt >>> y.toNat | null | true |
TopologicalSpace.Opens.map_id_obj | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)).obj U = U | null | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
(lα : Q(LT «$α»)) →
{a b : Q(«$α»)} →
Mathlib.Meta.NormNum.Result a →
Mathlib.Meta.NormNum.Result b →
have e := q(«$a» < «$b»);
Lean.MetaM (Mathlib.Meta.NormNum.Result e) | null | true |
normSeminorm | Mathlib.Analysis.Normed.Module.Seminorm.Norm | (𝕜 : Type u_1) →
(E : Type u_2) →
[inst : NormedField 𝕜] → [inst_1 : SeminormedAddCommGroup E] → [inst_2 : NormedSpace 𝕜 E] → Seminorm 𝕜 E | The norm of a seminormed space as a seminorm. | true |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.zero_pow.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | null | false |
CategoryTheory.ShortComplex.Splitting.map | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{S : CategoryTheory.ShortComplex C} →
S.Splittin... | If a short complex `S` has a splitting and `F` is an additive functor, then
`S.map F` also has a splitting. | true |
Lean.PersistentHashMap.Node.brecOn_3 | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
{motive_2 : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{motive_3 : List (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{... | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.isSelfAdjoint_finsuppSum | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] {K : Matrix X X (V →L[𝕜] V)},
K.IsHermitian → ∀ (f : X →₀ V →L[𝕜] V), IsSelfAdjoint (f.sum fun i xi => f.sum fun j xj => star xi * K i j * xj) | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.le_ofSliceFrom_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceFrom p₀).Pos} {q : s.Pos},
(String.Pos.ofSliceFrom p < q) = ∃ (h : p₀ ≤ q), p < p₀.sliceFrom q h | null | false |
MeasureTheory.L1.SimpleFunc.setToL1SCLM.congr_simp | Mathlib.MeasureTheory.Integral.SetToL1.L1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T T_1 : Set α → E →L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ} (e_C : C = C_1)
(hT : MeasureTheory.Domin... | null | true |
deriv_const_rpow_id | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {x a : ℝ}, 0 < a → deriv (fun x => a ^ x) x = Real.log a * a ^ x | null | true |
Subgroup.prod_eq_bot_iff._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N},
(H.prod K = ⊥) = (H = ⊥ ∧ K = ⊥) | null | false |
specializingMap_iff_isClosed_image_closure_singleton | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f → (SpecializingMap f ↔ ∀ (x : X), IsClosed (f '' closure {x})) | null | true |
Module.Basis.traceDual_traceDual | Mathlib.RingTheory.Trace.Basic | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {ι : Type w}
[inst_3 : FiniteDimensional K L] [inst_4 : Algebra.IsSeparable K L] [inst_5 : Finite ι] [inst_6 : DecidableEq ι]
(b : Module.Basis ι K L), b.traceDual.traceDual = b | null | true |
Lean.Meta.Match.Pattern.val.sizeOf_spec | Lean.Meta.Match.Basic | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Match.Pattern.val e) = 1 + sizeOf e | null | true |
MeasureTheory.MemLp.of_fst_of_snd_prodLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p 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.MemLp (fun x => (f x).fst) p μ ∧ MeasureTheory.MemLp (fun x => (f x)... | **Alias** of the reverse direction of `MeasureTheory.memLp_prodLp_iff`. | true |
Equiv.completeAtomicBooleanAlgebra._proof_7 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CompleteAtomicBooleanAlgebra β], e (e.symm ⊤) = ⊤ | null | false |
Delone.DeloneSet.mapIsometry_refl | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} [inst : MetricSpace X] (D : Delone.DeloneSet X),
(Delone.DeloneSet.mapIsometry (IsometryEquiv.refl X)) D = D | null | true |
Set.inv_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : DivisionMonoid M] {a : M}, a ∈ Set.center M → a⁻¹ ∈ Set.center M | null | true |
instRingWithIdealFilter._proof_5 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] (x : IdealFilter A) (a b c : WithIdealFilter x), a + b + c = a + (b + c) | null | false |
QuotientGroup.mulEquivPiModRangePowMonoidHom._proof_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {ι : Type u_1} (A : ι → Type u_2) [inst : (i : ι) → CommGroup (A i)] (n : ℕ), (fun x => ↑(1 x)) = 1 | null | false |
MeasureTheory.Measure.pi.isOpenPosMeasure | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)) [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → TopologicalSpace (α i)] [∀ (i : ι), (μ i).IsOpenPosMeasure],
(MeasureTheory.Measure.pi μ).IsOpenPosMeasure | null | true |
LocallyConstant.indicator_of_notMem | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : Zero R] {U : Set X} (f : LocallyConstant X R)
{a : X} (hU : IsClopen U), a ∉ U → (f.indicator hU) a = 0 | null | true |
Lean.Order.PredTrans.ext_iff | Std.Internal.Order.PredTrans | ∀ {Pred : Type u} {EPred : Type v} {α : Type w} {x y : Lean.Order.PredTrans Pred EPred α},
x = y ↔ ∀ (post : α → Pred) (epost : EPred), x.apply post epost = y.apply post epost | null | true |
Lean.Grind.instCommRingUSize._proof_5 | Init.GrindInstances.Ring.UInt | ∀ (n : ℕ) (a : USize), ↑↑n * a = ↑n * a | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x.toInt < 0 → 0 ≤ x.toInt → False | null | false |
Lean.Compiler.LCNF.specExtension | Lean.Compiler.LCNF.SpecInfo | Lean.SimplePersistentEnvExtension Lean.Compiler.LCNF.SpecEntry Lean.Compiler.LCNF.SpecState | Extension for storing `SpecParamInfo` for declarations being compiled.
Remark: we only store information for declarations that will be specialized.
| true |
Bipointed.swapEquiv_functor_map_toFun | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a | null | true |
Nat.greatestFib.eq_1 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (n : ℕ), n.greatestFib = Nat.findGreatest (fun k => Nat.fib k ≤ n) (n + 1) | null | true |
surjOn_Icc_of_monotone_surjective | Mathlib.Order.Interval.Set.SurjOn | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PartialOrder β] {f : α → β},
Monotone f → Function.Surjective f → ∀ {a b : α}, a ≤ b → Set.SurjOn f (Set.Icc a b) (Set.Icc (f a) (f b)) | null | true |
MeasureTheory.JordanDecomposition.zero_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.JordanDecomposition.posPart 0 = 0 | null | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_14 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ), i < j → j < k → k < tail.length + 1 → i < tail.length | null | false |
MapClusterPt.prodMap | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {α : Type u_2} {β : Type u_3}
{f : α → X} {g : β → Y} {la : Filter α} {lb : Filter β} {x : X} {y : Y},
MapClusterPt x la f → MapClusterPt y lb g → MapClusterPt (x, y) (la ×ˢ lb) (Prod.map f g) | null | true |
Std.Tactic.BVDecide.Normalize.BitVec.zero_ult' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), (0#w).ult a = !a == 0#w | null | true |
GroupExtension.Splitting.semidirectProductMulEquiv | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → (s : S.Splitting) → N ⋊[s.conjAct] G ≃* E | The group associated to a split extension is isomorphic to a semidirect product. | true |
CompTriple.IsId.rec | Mathlib.Logic.Function.CompTypeclasses | {M : Type u_1} →
{σ : M → M} →
{motive : CompTriple.IsId σ → Sort u} → ((eq_id : σ = id) → motive ⋯) → (t : CompTriple.IsId σ) → motive t | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb_flattenList._proof_1 | Init.Data.BitVec.Lemmas | ∀ (hi lo : ℕ) {w : ℕ} (vs : List (BitVec w)),
lo ≤ hi → w * (lo / w) ≤ lo → ¬hi - w * (lo / w) - (lo - w * (lo / w)) = hi - lo → False | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go._unary._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (input : aig.RefVec w)
(distance curr : ℕ) (hcurr : curr ≤ w) (s : aig.RefVec curr) (hidx : curr < w) (hdist : ¬curr < distance),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.casesOn hc... | null | false |
neg_add_cancel_comm_assoc | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), -a + (b + a) = b | null | true |
Set.countable_setOf_finite_subset | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Countable → {t | t.Finite ∧ t ⊆ s}.Countable | **Alias** of `Set.countable_ofPred_finite_subset`.
---
The set of finite subsets of a countable set is countable. | true |
CategoryTheory.Pi.μ_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I) (X Y : (i : I) → C i),
CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Pi.eval C i) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalC... | null | true |
IntervalIntegrable.mono_set | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b c d : ℝ}
{μ : MeasureTheory.Measure ℝ} [TopologicalSpace.PseudoMetrizableSpace ε],
IntervalIntegrable f μ a b → Set.uIcc c d ⊆ Set.uIcc a b → IntervalIntegrable f μ c d | null | true |
Set.restrict_ite_compl | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [inst : (x : α) → Decidable (x ∈ s)],
(sᶜ.domRestrict fun a => if a ∈ s then f a else g a) = sᶜ.domRestrict g | **Alias** of `Set.domRestrict_ite_compl`. | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution_map | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, ... | null | true |
descPochhammer_eval_eq_descFactorial | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R] (n k : ℕ), Polynomial.eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k) | null | true |
ONote.NFBelow | Mathlib.SetTheory.Ordinal.Notation | ONote → Ordinal.{0} → Prop | `NFBelow o b` says that `o` is a normal form ordinal notation satisfying `repr o < ω ^ b`. | true |
Units.instDecidableEq | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → [DecidableEq α] → DecidableEq αˣ | Units have decidable equality if the base `Monoid` has decidable equality. | true |
_private.Mathlib.Analysis.Complex.Convex.0.Complex.instPathConnectedSpaceUnits._simp_3 | Mathlib.Analysis.Complex.Convex | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
OneHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [One M] → [One N] → [FunLike F M N] → Prop | `OneHomClass F M N` states that `F` is a type of one-preserving homomorphisms.
You should extend this typeclass when you extend `OneHom`.
| true |
Std.Sat.CNF.Clause.instForIn'LiteralInferInstanceMembershipOfMonad | Std.Sat.CNF.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} → [Monad m] → ForIn' m (Std.Sat.CNF.Clause α) (Std.Sat.Literal α) inferInstance | null | true |
Std.Do.«term_∧ₚ_» | Std.Do.PostCond | Lean.TrailingParserDescr | Conjunction of postconditions.
This is defined pointwise, as the conjunction of the assertions about the return value and the
conjunctions of the assertions about each potential exception.
| true |
R0Space.closure_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R0Space X] (x : X), closure {x} = (nhds x).ker | null | true |
Fin.val_natCast | Mathlib.Data.Fin.Basic | ∀ (a n : ℕ) [inst : NeZero n], ↑↑a = a % n | null | true |
OneHom.coe_id | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} [inst : One M], ⇑(OneHom.id M) = id | null | true |
Std.DHashMap.Const.getKey!_unitOfList_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α] {l : List α} {k : α},
l.contains k = false → (Std.DHashMap.Const.unitOfList l).getKey! k = default | null | true |
Finset.SupIndep.le_sup_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s t : Finset ι} {f : ι → α} {i : ι},
s.SupIndep f → t ⊆ s → i ∈ s → (∀ (i : ι), f i ≠ ⊥) → (f i ≤ t.sup f ↔ i ∈ t) | null | true |
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.nonempty_inter_of_coverMincard._simp_1_1 | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.L1.0.MeasureTheory.SimpleFunc.integral_mono_measure._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {p : β → Prop},
(∀ y ∈ f.range, p y) = ∀ (x : α), p (f x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.