name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UniqueAdd.addHom_preimage | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] (f : G →ₙ+ H) (hf : Function.Injective ⇑f) (a0 b0 : G)
{A B : Finset H}, UniqueAdd A B (f a0) (f b0) → UniqueAdd (A.preimage ⇑f ⋯) (B.preimage ⇑f ⋯) a0 b0 | `UniqueAdd` is preserved by inverse images under injective, additive maps. | true |
NumberField.IsTotallyComplex.casesOn | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | {K : Type u_1} →
[inst : Field K] →
{motive : NumberField.IsTotallyComplex K → Sort u} →
(t : NumberField.IsTotallyComplex K) →
((isComplex : ∀ (v : NumberField.InfinitePlace K), v.IsComplex) → motive ⋯) → motive t | null | false |
Set.Nonempty.of_vadd_right | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s : Set α} {t : Set β}, (s +ᵥ t).Nonempty → t.Nonempty | null | true |
minpoly.mem_range_of_degree_eq_one | Mathlib.FieldTheory.Minpoly.Basic | ∀ (A : Type u_1) {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] (x : B),
(minpoly A x).degree = 1 → x ∈ (algebraMap A B).range | null | true |
CategoryTheory.Pseudofunctor.mapComp_assoc_left_hom_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) {Z : F.obj a ⟶ F.obj d}
(h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (F.map f) (F.map g)... | null | true |
Prod.normedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedRing α] [inst_1 : NormedRing β] (a : α × β), 1 * a = a | null | false |
Polynomial.coeff_eq_zero_of_lt_trailingDegree | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, ↑n < p.trailingDegree → p.coeff n = 0 | null | true |
ProofWidgets.Penrose.DiagramProps.maxOptSteps | ProofWidgets.Component.PenroseDiagram | ProofWidgets.Penrose.DiagramProps → ℕ | Maximum number of optimization steps to take before showing the diagram.
Optimization may converge earlier, before taking this many steps. | true |
Matroid.IsBase.ncard_eq_ncard_of_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {B₁ B₂ : Set α}, M.IsBase B₁ → M.IsBase B₂ → B₁.ncard = B₂.ncard | null | true |
IsSimpleOrder.instFinite | Mathlib.Order.Atoms.Finite | ∀ {α : Type u_1} [inst : LE α] [inst_1 : BoundedOrder α] [IsSimpleOrder α], Finite α | null | true |
CompactlySupportedContinuousMap.mk.sizeOf_spec | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_5} {β : Type u_6} [inst : TopologicalSpace α] [inst_1 : Zero β] [inst_2 : TopologicalSpace β]
[inst_3 : SizeOf α] [inst_4 : SizeOf β] (toContinuousMap : C(α, β))
(hasCompactSupport' : HasCompactSupport toContinuousMap.toFun),
sizeOf { toContinuousMap := toContinuousMap, hasCompactSupport' := hasComp... | null | true |
CochainComplex.HomComplex.leftHomologyData'._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m p : ℤ) (hm : n + 1 = m) (hp : m + 1 = p)
(s :
CategoryTheory.Limits.Cofork
((CochainComplex.HomComplex.Cocycle.isKernel K L m p hp).lift
(CategoryTheory.Limits.Ker... | null | false |
Std.Http.Internal.Char.vchar | Std.Http.Internal.Char | Char → Bool | vchar = %x21-7E
; Visible (printing) ASCII characters.
| true |
Sym2.Mem.other' | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → [DecidableEq α] → {a : α} → {z : Sym2 α} → a ∈ z → α | Get the other element of the unordered pair using the decidable equality.
This is the computable version of `Mem.other`. | true |
CategoryTheory.Functor.IsLeftKanExtension.recOn | Mathlib.CategoryTheory.Functor.KanExtension.Basic | {C : Type u_1} →
{H : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} D] →
{F' : CategoryTheory.Functor D H} →
{L : CategoryTheory.Functor C... | null | false |
CategoryTheory.Functor.category._proof_4 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {X Y : CategoryTheory.Functor C D} (f : CategoryTheory.NatTrans X Y),
f.vcomp (CategoryTheory.NatTrans.id Y) = f | null | false |
Std.Slice.Internal.SubarrayData.mk._flat_ctor | Init.Data.Array.Subarray | {α : Type u} →
(array : Array α) → (start stop : ℕ) → start ≤ stop → stop ≤ array.size → Std.Slice.Internal.SubarrayData α | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_7 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
LinearEquiv.extendScalarsOfIsLocalization._proof_1 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_4} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_2) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_3} {N : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[i... | null | false |
Lean.Meta.Sym.Simp.SymSimpVariant.ctorIdx | Lean.Meta.Sym.Simp.Variant | Lean.Meta.Sym.Simp.SymSimpVariant → ℕ | null | false |
_private.Mathlib.Data.Set.Insert.0.Set.ssubset_insert._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, a ∉ s → s ⊂ insert a s | null | false |
hasFDerivAt_comp_add_right | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (a : E), HasFDerivAt (fun x => f (x + a)) f' x ↔ HasFDerivAt f f' (x + a) | null | true |
TopologicalSpace.Clopens.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isClopen' : IsClopen carrier) (carrier_1 : Set α)
(isClopen'_1 : IsClopen carrier_1),
({ carrier := carrier, isClopen' := isClopen' } = { carrier := carrier_1, isClopen' := isClopen'_1 }) =
(carrier = carrier_1) | null | true |
Std.DTreeMap.Internal.Impl.SizedBalancedTree.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} →
(impl : Std.DTreeMap.Internal.Impl α β) →
impl.Balanced → lb ≤ impl.size → impl.size ≤ ub → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub | null | false |
MonObj.mopEquiv | Mathlib.CategoryTheory.Monoidal.Opposite.Mon | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon C ≌ CategoryTheory.Mon Cᴹᵒᵖ | The equivalence of categories between monoids internal to `C`
and monoids internal to the monoidal opposite of `C`. | true |
Nat.clog_zero_right | Mathlib.Data.Nat.Log | ∀ (b : ℕ), Nat.clog b 0 = 0 | null | true |
hasDerivWithinAt_sdiff_singleton | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' (s \ {x}) x ↔ HasDerivWithinAt f f' s x | null | true |
CategoryTheory.nerve.σ₀_mk₀_eq | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : C),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve C) 0))
(CategoryTheory.ComposableArrows.mk₀ x) =
CategoryTheory.ComposableArrows.mk₁ (CategoryTheory.CategoryStruct.id x) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.Reachable.dist_triangle_right._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V},
G.Reachable v w → ∀ (u : V), G.Reachable u w → ↑(G.dist u w) ≤ ↑(G.dist u v) + ↑(G.dist v w) | null | false |
_private.Mathlib.Algebra.Module.TransferInstance.0.Equiv.noZeroSMulDivisors._simp_1_1 | Mathlib.Algebra.Module.TransferInstance | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (y = e.symm x) = (e y = x) | null | false |
CategoryTheory.Subobject.Classifier.mkOfTerminalΩ₀_χ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (Ω₀ : C) (t : CategoryTheory.Limits.IsTerminal Ω₀) (Ω : C)
(truth : Ω₀ ⟶ Ω) (χ : {U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ Ω)
(isPullback :
∀ {U X : C} (m : U ⟶ X) [inst_1 : CategoryTheory.Mono m], CategoryTheory.IsPullback m (t.from U) (χ m... | null | true |
Class.instCompleteLattice._proof_24 | Mathlib.SetTheory.ZFC.Class | ∀ (s : Set Class.{u_1}), IsGLB s (sInf s) | null | false |
Array.replicate_append_replicate | Init.Data.Array.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {m : ℕ}, Array.replicate n a ++ Array.replicate m a = Array.replicate (n + m) a | null | true |
_private.Mathlib.Analysis.Fourier.FourierTransformDeriv.0.VectorFourier.norm_iteratedFDeriv_fourierPowSMulRight._proof_1_5 | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {k : ℕ} (i : ℕ), k - i ≤ k | null | false |
instDecidableIff._proof_2 | Init.Core | ∀ {p q : Prop}, p → ¬q → (p ↔ q) → False | null | false |
_private.Mathlib.Probability.Kernel.Composition.MeasureCompProd.0.MeasureTheory.Measure.compProd_eq_zero_iff._simp_1_1 | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (μ = 0) = (μ Set.univ = 0) | null | false |
Polynomial.taylor_mul | Mathlib.Algebra.Polynomial.Taylor | ∀ {R : Type u_1} [inst : CommSemiring R] (r : R) (p q : Polynomial R),
(Polynomial.taylor r) (p * q) = (Polynomial.taylor r) p * (Polynomial.taylor r) q | null | true |
_private.Mathlib.RingTheory.FiniteType.0.Algebra.FiniteType.of_surjective._simp_1_2 | Mathlib.RingTheory.FiniteType | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) {y : B}, (y ∈ φ.range) = ∃ x, φ x = y | null | false |
Lean.Lsp.LeanDidOpenTextDocumentParams.rec | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanDidOpenTextDocumentParams → Sort u} →
((toDidOpenTextDocumentParams : Lean.Lsp.DidOpenTextDocumentParams) →
(dependencyBuildMode? : Option Lean.Lsp.DependencyBuildMode) →
motive
{ toDidOpenTextDocumentParams := toDidOpenTextDocumentParams,
dependencyBuildMode... | null | false |
fixingSubgroup_union | Mathlib.GroupTheory.GroupAction.FixingSubgroup | ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α] {s t : Set α},
fixingSubgroup M (s ∪ t) = fixingSubgroup M s ⊓ fixingSubgroup M t | Fixing subgroup of union is intersection | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.σ_σ₀Iter'._proof_1_8 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ}, i + m = n + 1 → m + 1 + i = n + 1 + 1 | null | false |
Lean.IR.IRType.erased.sizeOf_spec | Lean.Compiler.IR.Basic | sizeOf Lean.IR.IRType.erased = 1 | null | true |
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.forall_uIoc_iff._simp_1_2 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (k i j : ℕ), i + k = j → ¬i ≤ j → False | null | false |
MeasureTheory.hausdorffMeasure_orthogonalProjection_le | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {𝕜 : Type u_4} {E : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (K : Submodule 𝕜 E) [inst_5 : K.HasOrthogonalProjection] (d : ℝ)
(s : Set E),
0 ≤ d →
(MeasureTheory.Measure.hausdorffMeasure d) (⇑K.ortho... | **Alias** of `MeasureTheory.hausdorffMeasure_orthogonalProjectionOnto_le`.
---
Let `s` be a subset of `𝕜`-inner product space, and `K` a subspace. Then the `d`-dimensional
Hausdorff measure of the orthogonal projection of `s` onto `K` is less than or equal to the
`d`-dimensional Hausdorff measure of `s`.
| true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_129 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (w_1 start : ℕ)
(expr : Std.Tactic.BVDecide.BVExpr w_1), ¬llhs.shiftLeft lrhs = Std.Tactic.BVDecide.BVExpr.extract start w expr | null | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_24 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (k : ℕ), k + 1 ≤ tail.length → -1 * ↑k + 1 ≤ 0 → k - 1 < tail.length | null | false |
_private.Mathlib.Analysis.Complex.JensenFormula.0.AnalyticOnNhd.sum_divisor_le._simp_1_5 | Mathlib.Analysis.Complex.JensenFormula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
RBTree.RBNode.exists_find?_insert_self | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {c : RBTree.RBColor} {n : ℕ} {v : α} [Std.TransCmp cmp]
[RBTree.RBNode.IsCut cmp cut] {t : RBTree.RBNode α},
t.Balanced c n →
RBTree.RBNode.Ordered cmp t →
cut v = Ordering.eq → ∃ x, RBTree.RBNode.find? cut (RBTree.RBNode.insert cmp t v) = som... | null | true |
LinearMap.finrank_maxGenEigenspace_eq | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_3} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M]
[inst_3 : Module.Finite K M] (φ : Module.End K M) (μ : K),
Module.finrank K ↥(φ.maxGenEigenspace μ) = Polynomial.rootMultiplicity μ (LinearMap.charpoly φ) | null | true |
_private.Mathlib.Algebra.Homology.Additive.0.CategoryTheory.NatIso.mapHomologicalComplex._simp_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (c : ComplexShape ι) {F G H : CategoryTheory.Functor W₁ W₂}
[in... | null | false |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Basic.0.Polynomial.coprime_of_root_cyclotomic._simp_1_2 | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
MvPolynomial.universalFactorizationMapPresentation_val | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k) (a : Fin m ⊕ Fin k),
(MvPolynomial.universalFactorizationMapPresentation R n m k hn).val a =
Sum.elim (fun x => MvPolynomial.X x ⊗ₜ[R] 1) (fun x => 1 ⊗ₜ[R] MvPolynomial.X x) a | null | true |
AlgebraicGeometry.isLocallyNoetherian_iff_of_affine_openCover | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [∀ (i : 𝒰.I₀), AlgebraicGeometry.IsAffine (𝒰.X i)],
AlgebraicGeometry.IsLocallyNoetherian X ↔ ∀ (i : 𝒰.I₀), IsNoetherianRing ↑((𝒰.X i).presheaf.obj (Opposite.op ⊤)) | A version of `isLocallyNoetherian_iff_of_iSup_eq_top` using `Scheme.OpenCover`. | true |
Convex.mul_sub_lt_image_sub_of_lt_deriv | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {D : Set ℝ},
Convex ℝ D →
∀ {f : ℝ → ℝ},
ContinuousOn f D →
DifferentiableOn ℝ f (interior D) →
∀ {C : ℝ}, (∀ x ∈ interior D, C < deriv f x) → ∀ x ∈ D, ∀ y ∈ D, x < y → C * (y - x) < f y - f x | Let `f` be a function continuous on a convex (or, equivalently, connected) subset `D`
of the real line. If `f` is differentiable on the interior of `D` and `C < f'`, then
`f` grows faster than `C * x` on `D`, i.e., `C * (y - x) < f y - f x` whenever `x, y ∈ D`,
`x < y`. | true |
CategoryTheory.Functor.ι_leftKanExtensionObjIsoColimit_hom_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : Ca... | null | true |
Lean.Elab.Info.ofPartialTermInfo.elim | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
t.ctorIdx = 2 → ((i : Lean.Elab.PartialTermInfo) → motive (Lean.Elab.Info.ofPartialTermInfo i)) → motive t | null | false |
Std.DTreeMap.Internal.RciSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rci α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | null | true |
imp_iff_not_or | Mathlib.Logic.Basic | ∀ {a b : Prop}, a → b ↔ ¬a ∨ b | null | true |
_private.Mathlib.AlgebraicGeometry.Cover.QuasiCompact.0.AlgebraicGeometry.QuasiCompactCover.instPullback₁Scheme._simp_2 | Mathlib.AlgebraicGeometry.Cover.QuasiCompact | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
IsTopologicalGroup.leftUniformSpace | Mathlib.Topology.Algebra.IsUniformGroup.Defs | (G : Type u_1) → [inst : Group G] → [inst_1 : TopologicalSpace G] → [IsTopologicalGroup G] → UniformSpace G | The left uniformity on a topological group (as opposed to the right uniformity).
Warning: in general the right and left uniformities do not coincide and so one does not obtain a
`IsUniformGroup` structure. Two important special cases where they _do_ coincide are for
commutative groups (see `isUniformGroup_of_commGroup... | true |
OrderIso.dualAntisymmetrization._proof_2 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a : α),
Quotient.map' id ⋯ (Quotient.map' id ⋯ (Quotient.mk'' a)) = Quotient.mk'' a | null | false |
_private.Mathlib.Tactic.Algebraize.0.Lean.Attr.algebraizeGetParam.match_1 | Mathlib.Tactic.Algebraize | (motive : Lean.Name → Sort u_1) →
(thm : Lean.Name) → ((t : String) → motive (`RingHom.str t)) → ((x : Lean.Name) → motive x) → motive thm | null | false |
_private.Mathlib.CategoryTheory.CommSq.0.CategoryTheory.CommSq.LiftStruct.ext.match_1 | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_2} {inst : CategoryTheory.Category.{u_1, u_2} C} {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
{g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (motive : sq.LiftStruct → Prop) (h : sq.LiftStruct),
(∀ (l : B ⟶ X) (fac_left : CategoryTheory.CategoryStruct.comp i l = f)
(fac_right : CategoryThe... | null | false |
ProbabilityTheory.iCondIndepSet | Mathlib.Probability.Independence.Conditional | {Ω : Type u_1} →
{ι : Type u_2} →
(m' : MeasurableSpace Ω) →
{mΩ : MeasurableSpace Ω} →
[StandardBorelSpace Ω] →
m' ≤ mΩ →
(ι → Set Ω) →
(μ : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.iCondIndepSet._auto_1) →
[MeasureTheory.IsFiniteMeas... | A family of sets is conditionally independent if the family of measurable space structures they
generate is conditionally independent. For a set `s`, the generated measurable space has measurable
sets `∅, s, sᶜ, univ`.
See `ProbabilityTheory.iCondIndepSet_iff`. | true |
Real.one_lt_sqrt_two | Mathlib.Analysis.Real.Sqrt | 1 < √2 | null | true |
_private.Lean.Meta.Injective.0.Lean.Meta.andProjections.go | Lean.Meta.Injective | Lean.Expr → Lean.Expr → Array Lean.Expr → Lean.MetaM (Array Lean.Expr) | null | true |
Quot.lift₂._proof_1 | Mathlib.Data.Quot | ∀ {α : Sort u_3} {β : Sort u_1} {γ : Sort u_2} {r : α → α → Prop} {s : β → β → Prop} (f : α → β → γ)
(hr : ∀ (a : α) (b₁ b₂ : β), s b₁ b₂ → f a b₁ = f a b₂),
(∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → f a₁ b = f a₂ b) → ∀ (a₁ a₂ : α), r a₁ a₂ → Quot.lift (f a₁) ⋯ = Quot.lift (f a₂) ⋯ | null | false |
IdemSemiring.ofSemiring | Mathlib.Algebra.Order.Kleene | {α : Type u_1} → [inst : Semiring α] → (∀ (a : α), a + a = a) → IdemSemiring α | Construct an idempotent semiring from an idempotent addition. | true |
Mathlib.Tactic.Says.says.verify | Mathlib.Tactic.Says | Lean.Option Bool | If this option is `true`, verify for `X says Y` that `X says` outputs `Y`. | true |
Mathlib.Tactic.Algebra.add_assoc_rev | Mathlib.Tactic.Algebra.Lemmas | ∀ {R : Type u_1} [sR : CommSemiring R] (a b c : R), a + (b + c) = a + b + c | null | true |
_private.Mathlib.Data.List.Permutation.0.List.count_permutations'Aux_self._simp_1_2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.widePullbackShapeEquivMap.match_3 | Mathlib.CategoryTheory.WithTerminal.Basic | {J : Type u_1} →
(motive :
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝ x ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝ y) →
Sort u_2) →
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(f :
... | null | false |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.mk.inj | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)} {unit : CategoryTheory.Functor.id C ⟶ F.comp G}
{counit : G.comp ... | null | true |
SMulPosMono | Mathlib.Algebra.Order.Module.Defs | (α : Type u_1) → (β : Type u_2) → [SMul α β] → [Preorder α] → [Preorder β] → [Zero β] → Prop | Typeclass for monotonicity of scalar multiplication by nonnegative elements on the left,
namely `a₁ ≤ a₂ → a₁ • b ≤ a₂ • b` if `0 ≤ b`.
You should usually not use this very granular typeclass directly, but rather a typeclass like
`IsOrderedModule`. | true |
_private.Batteries.Data.List.Lemmas.0.List.pos_findIdxNth_getElem._proof_1_10 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n : ℕ}
{h : List.findIdxNth p (head :: tail) n < (head :: tail).length},
¬n = 0 → ¬p head = true → List.findIdxNth p tail n < tail.length | null | false |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Reduce.0.Lean.Elab.Tactic.Do.Internal.VCGen.reduceHead?._sparseCasesOn_1 | Lean.Elab.Tactic.Do.Internal.VCGen.Reduce | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_iff_exists._simp_1_5 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {n : Type u_3} {α : Type u_11} [inst : Semiring α] [inst_1 : DecidableEq n] [inst_2 : Fintype n] [Nonempty n]
{r s : α}, ((Matrix.scalar n) r = (Matrix.scalar n) s) = (r = s) | null | false |
Lean.Compiler.LCNF.Code.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} → ℕ → Sort (max 1 u) | null | false |
Std.instCommutativeAnd | Init.Core | Std.Commutative And | null | true |
IsDenseInducing.casesOn | Mathlib.Topology.DenseEmbedding | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{i : α → β} →
{motive : IsDenseInducing i → Sort u} →
(t : IsDenseInducing i) →
((toIsInducing : Topology.IsInducing i) → (dense : DenseRange i) → motive ⋯) → motive t | null | false |
ModuleCat.monModuleEquivalenceAlgebra._proof_29 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : AlgCat R) (x : R), id ((algebraMap R ↑A) x) = id ((algebraMap R ↑A) x) | null | false |
Lean.Elab.Term.ContainsPendingMVar.visit | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Elab.Term.ContainsPendingMVar.M Unit | See `containsPostponedTerm` | true |
IntermediateField.AdjoinSimple.norm_gen_eq_prod_roots | Mathlib.RingTheory.Norm.Basic | ∀ {K : Type u_4} {L : Type u_5} {F : Type u_6} [inst : Field K] [inst_1 : Field L] [inst_2 : Field F]
[inst_3 : Algebra K L] [inst_4 : Algebra K F] (x : L),
(Polynomial.map (algebraMap K F) (minpoly K x)).Splits →
(algebraMap K F) ((Algebra.norm K) (IntermediateField.AdjoinSimple.gen K x)) = ((minpoly K x).aroo... | null | true |
SSet.prodStdSimplex.pairingCore.IsType₂.type₁_index | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
(hx : SSet.prodStdSimplex.pairingCore.IsType₂ x) {d : ℕ} (hd : x.dim = d),
(hx.type₁ hd).index = SSet.prodStdSimplex.pairingCore.min x hd | null | true |
IsTorsion.subgroup | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : Group G], Monoid.IsTorsion G → ∀ (H : Subgroup G), Monoid.IsTorsion ↥H | Subgroups of torsion groups are torsion groups. | true |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go._unary._proof_1 | Lean.Data.RArray | ∀ {n : ℕ},
WellFounded
(invImage
(fun x =>
PSigma.casesOn x fun lb ub => PSigma.casesOn ub fun ub h1 => PSigma.casesOn h1 fun h1 h2 => (ub, ub - lb))
Prod.instWellFoundedRelation).1 | null | false |
MonoidHom.mker | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : MulOneClass M] →
[inst_1 : MulOneClass N] →
{F : Type u_4} → [inst_2 : FunLike F M N] → [mc : MonoidHomClass F M N] → F → Submonoid M | The multiplicative kernel of a monoid hom is the submonoid of elements `x : G` such
that `f x = 1`. | true |
Multiset.decidableExistsMultiset._proof_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {p : α → Prop} (l : List α), (∃ a ∈ l, p a) ↔ ∃ x ∈ ⟦l⟧, p x | null | false |
MvPolynomial.instIsCancelAddOfIsLeftCancelAdd | Mathlib.Algebra.MvPolynomial.Division | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] [IsLeftCancelAdd R], IsCancelAdd (MvPolynomial σ R) | null | true |
PolishSpace.measurableEquivNatBoolOfNotCountable._proof_1 | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1}, ¬Countable α → ¬Set.univ.Countable | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.List.filterMap.match_1.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b | null | true |
_private.Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap.0.ContinuousLinearMap.toLinearMap₁₂_injective._simp_1_2 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {f g : M₁ →SL[σ₁₂] M₂}... | null | false |
LipschitzWith.integral_inv_smul_sub_mul_tendsto_integral_lineDeriv_mul | Mathlib.Analysis.Calculus.Rademacher | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{C : NNReal} {f g : E → ℝ} {μ : MeasureTheory.Measure E} [FiniteDimensional ℝ E] [μ.IsAddHaarMeasure],
LipschitzWith C f →
MeasureTheory.Integrable g μ →
∀ (v : E),
Filter.Tendsto ... | null | true |
TwoSidedIdeal.equivMatrix.congr_simp | Mathlib.LinearAlgebra.Matrix.Ideal | ∀ {R : Type u_1} {n : Type u_2} [inst : NonAssocRing R] [inst_1 : Fintype n] [inst_2 : Nonempty n]
[inst_3 : DecidableEq n], TwoSidedIdeal.equivMatrix = TwoSidedIdeal.equivMatrix | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_alterKey._simp_1_4 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValueCast a l h) = Std.Internal.List.getValueCast? a l | null | false |
LinearIndependent.fintypeLinearCombination_injective | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Fintype ι],
LinearIndependent R v → Function.Injective ⇑(Fintype.linearCombination R v) | **Alias** of the forward direction of `linearIndependent_iff_injective_fintypeLinearCombination`. | true |
instAlgebraCliffordAlgebra | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (Q : QuadraticForm R M) → Algebra R (CliffordAlgebra Q) | null | true |
Lean.SubExpr.Pos.fromString? | Lean.SubExpr | String → Except String Lean.SubExpr.Pos | null | true |
MeasureTheory.hittingBtwn_mem_Icc | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β}
{n m : ι}, n ≤ m → ∀ (ω : Ω), MeasureTheory.hittingBtwn u s n m ω ∈ Set.Icc n m | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.