name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.IterM._sizeOf_inst | Init.Data.Iterators.Basic | {α : Type w} →
(m : Type w → Type w') →
(β : Type w) → [SizeOf α] → [(a : Type w) → SizeOf (m a)] → [SizeOf β] → SizeOf (Std.IterM m β) | null | false |
_private.Plausible.Gen.0.Plausible.Gen.backtrackFuel.match_1 | Plausible.Gen | (motive : ℕ → Sort u_1) → (fuel : ℕ) → (Unit → motive Nat.zero) → ((fuel' : ℕ) → motive fuel'.succ) → motive fuel | null | false |
MeasureTheory.Measure.pi.isAddHaarMeasure | 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 : ι) → AddGroup (α i)] [inst_4 : (i : ι) → TopologicalSpace (α i)] [∀ (i : ι), (μ i).IsAddHaarMeasure]
[∀ (i : ι),... | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rcc.forIn'_eq_if.match_1.eq_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {γ : Type u_1} (motive : ForInStep γ → Sort u_2) (c : γ) (h_1 : (c : γ) → motive (ForInStep.yield c))
(h_2 : (c : γ) → motive (ForInStep.done c)),
(match ForInStep.done c with
| ForInStep.yield c => h_1 c
| ForInStep.done c => h_2 c) =
h_2 c | null | true |
HomologicalComplex.HomologySequence.snakeInput._proof_37 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i j : ι),
CategoryTheory.Epi
((HomologicalComplex.HomologySequence.composableArrows₃ S.X₂ i j).map' 2 3
Homolog... | null | false |
CategoryTheory.DifferentialObject.mk._flat_ctor | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddMonoidWithOne S] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
(obj : C) →
(d : obj ⟶ (CategoryTheory.shiftFunctor C 1).obj ... | null | false |
PiTensorProduct.ofFinsuppEquiv'.eq_1 | Mathlib.LinearAlgebra.PiTensorProduct.Finsupp | ∀ {R : Type u_1} {ι : Type u_2} {κ : ι → Type u_3} [inst : CommSemiring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (κ i)] [inst_4 : DecidableEq R],
PiTensorProduct.ofFinsuppEquiv' =
PiTensorProduct.ofFinsuppEquiv.trans
(Finsupp.lcongr (Equiv.refl ((i : ι) → κ i)) ↑(Pi... | null | true |
Turing.TM0.Machine.map_respects | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} [inst : Inhabited Γ] {Γ' : Type u_2} [inst_1 : Inhabited Γ'] {Λ : Type u_3} [inst_2 : Inhabited Λ]
{Λ' : Type u_4} [inst_3 : Inhabited Λ'] (M : Turing.TM0.Machine Γ Λ) (f₁ : Turing.PointedMap Γ Γ')
(f₂ : Turing.PointedMap Γ' Γ) (g₁ : Turing.PointedMap Λ Λ') (g₂ : Λ' → Λ) {S : Set Λ},
Turing.TM0.S... | null | true |
Std.Http.Config.maxHeaderBytes | Std.Http.Server.Config | Std.Http.Config → ℕ | Maximum aggregate byte size of all header field lines in a single message
(name + value bytes plus 4 bytes per line for `: ` and `\r\n`). Default: 64 KiB.
| true |
ProbabilityTheory.gaussianReal_map_sub_const | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (y : ℝ),
MeasureTheory.Measure.map (fun x => x - y) (ProbabilityTheory.gaussianReal μ v) =
ProbabilityTheory.gaussianReal (μ - y) v | null | true |
LaurentPolynomial.ext | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] {p q : LaurentPolynomial R}, (∀ (a : ℤ), p a = q a) → p = q | null | true |
signedDist_triangle_left | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v : V) (p q r : P), ((signedDist v) p) q - ((signedDist v) p) r = ((signedDist v) r) q | null | true |
CategoryTheory.Functor.PreservesLeftKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] ... | `G.PreservesLeftKanExtension F L` asserts that `G` preserves all left Kan extensions
of `F` along `L`. See `PreservesLeftKanExtension.mk_of_preserves_isLeftKanExtension` for a
constructor taking a single left Kan extension as input. | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_1_6 | Mathlib.Algebra.Homology.ExactSequence | 2 < 2 + 1 | null | false |
ContinuousMap.exists_finite_sum_smul_approximation_of_mem_uniformity | Mathlib.Topology.UniformSpace.ProdApproximation | ∀ {X : Type u_1} {Y : Type u_2} {R : Type u_3} {V : Type u_4} [inst : TopologicalSpace X] [TotallyDisconnectedSpace X]
[T2Space X] [CompactSpace X] [inst_4 : TopologicalSpace Y] [CompactSpace Y] [inst_6 : AddCommGroup V]
[inst_7 : UniformSpace V] [IsUniformAddGroup V] {S : Set (V × V)} [inst_9 : TopologicalSpace R]... | A continuous function on `X × Y`, taking values in an `R`-module with a uniform structure,
can be uniformly approximated by sums of functions of the form `(x, y) ↦ f x • g y`.
Note that no continuity properties are assumed either for multiplication on `R`, or for the scalar
multiplication of `R` on `V`. | true |
Nat.gcd_dvd_gcd_mul_right_left | Init.Data.Nat.Gcd | ∀ (m n k : ℕ), m.gcd n ∣ (m * k).gcd n | null | true |
Lean.Meta.Grind.instInhabitedCasesEntry.default | Lean.Meta.Tactic.Grind.Cases | Lean.Meta.Grind.CasesEntry | null | true |
_private.Mathlib.RingTheory.Localization.NormTrace.0.Algebra.trace_localization._simp_1_1 | Mathlib.RingTheory.Localization.NormTrace | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
lp.instNormedSpace | Mathlib.Analysis.Normed.Lp.lpSpace | {𝕜 : Type u_1} →
{α : Type u_3} →
{E : α → Type u_4} →
{p : ENNReal} →
[inst : (i : α) → NormedAddCommGroup (E i)] →
[inst_1 : NormedField 𝕜] → [(i : α) → NormedSpace 𝕜 (E i)] → [inst_3 : Fact (1 ≤ p)] → NormedSpace 𝕜 ↥(lp E p) | null | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.buildInductionBody._unsafe_rec | Lean.Meta.Tactic.FunInd | Array Lean.FVarId →
Array Lean.FVarId →
Lean.Expr →
Lean.FVarId → Lean.FVarId → (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Tactic.FunInd.M2✝ Lean.Expr | null | false |
List.getElem_intersperse_two_mul_add_one | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {l : List α} {sep : α} {i : ℕ} (h : 2 * i + 1 < (List.intersperse sep l).length),
(List.intersperse sep l)[2 * i + 1] = sep | null | true |
CategoryTheory.Discrete.ctorIdx | Mathlib.CategoryTheory.Discrete.Basic | {α : Type u₁} → CategoryTheory.Discrete α → ℕ | null | false |
TwoSidedIdeal.recOn | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} →
[inst : NonUnitalNonAssocRing R] →
{motive : TwoSidedIdeal R → Sort u} →
(t : TwoSidedIdeal R) → ((ringCon : RingCon R) → motive { ringCon := ringCon }) → motive t | null | false |
CompleteLattice.mk._flat_ctor | Mathlib.Order.CompleteLattice.Defs | {α : Type u_8} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam →
(∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(∀ (a... | null | false |
Lean.Lsp.Ipc.expandModuleHierarchyImports | Lean.Data.Lsp.Ipc | ℕ → Lean.Lsp.DocumentUri → Lean.Lsp.Ipc.IpcM (Option Lean.Lsp.Ipc.ModuleHierarchy × ℕ) | null | true |
BoundedRandom.noConfusion | Mathlib.Control.Random | {P : Sort u_2} →
{m : Type u → Type u_1} →
{α : Type u} →
{inst : Preorder α} →
{t : BoundedRandom m α} →
{m' : Type u → Type u_1} →
{α' : Type u} →
{inst' : Preorder α'} →
{t' : BoundedRandom m' α'} →
m = m' → α = α' → inst ≍ ins... | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_362 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[[].length] + 1 ≤
List.findIdx (fun x => decide (x = w_1)) [g a, g (g a)] →
(List.findIdxs (fun x => decide (x = w_1)) [g a,... | null | false |
Stream'.Seq.update_cons_zero | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (f : α → α),
(Stream'.Seq.cons hd tl).update 0 f = Stream'.Seq.cons (f hd) tl | null | true |
Holor.assocLeft.eq_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds₁ ds₂ ds₃ : List ℕ}, Holor.assocLeft = cast ⋯ | null | true |
Finset.inv_empty | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Inv α], ∅⁻¹ = ∅ | null | true |
AlgebraicGeometry.Scheme.pretopology._proof_3 | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.IsMultiplicative],
(AlgebraicGeometry.Scheme.precoverage P).IsStableUnderComposition | null | false |
Fin.instNeZeroHAddNatOfNat_mathlib_1 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) [NeZero n], NeZero 1 | null | true |
WeierstrassCurve.Projective.Point | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → Type r | A nonsingular projective point on a Weierstrass curve `W`. | true |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.checkAllDeclNamesDistinct | Lean.Elab.MutualDef | Array Lean.Elab.PreDefinition → Lean.Elab.TermElabM Unit | Ensures that all declarations given by `preDefs` have distinct names.
Remark: we wait to perform this check until the pre-definition phase because we must account for
auxiliary declarations introduced by `where` and `let rec`.
| true |
CategoryTheory.Pretriangulated.invRotateIsoRotateRotateShiftFunctorNegOne | Mathlib.CategoryTheory.Triangulated.TriangleShift | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
CategoryTheory.Pretriangulated.invRotate C ≅
(CategoryTheory.Pretriangulated.r... | The inverse of the rotation of triangles can be expressed using a double
rotation and the shift by `-1`. | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle.0.CochainComplex.HomComplex.Cochain.δ_fromSingleMk._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {p q n : ℤ}, p + n = q → ∀ (n' q' : ℤ), p + n' = q' → ¬q + 1 = q' → ¬n + 1 = n' | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.getD.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] (a : α) (fallback : β),
Std.DHashMap.Internal.AssocList.getD a fallback Std.DHashMap.Internal.AssocList.nil = fallback | null | true |
_private.Mathlib.Topology.Instances.AddCircle.DenseSubgroup.0.dense_addSubgroupClosure_pair_iff._simp_1_8 | Mathlib.Topology.Instances.AddCircle.DenseSubgroup | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.Quotient.functor_additive | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (r : HomRel C)
[inst_2 : CategoryTheory.Congruence r]
(hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y), r f₁ f₂ → r g₁ g₂ → r (f₁ + g₁) (f₂ + g₂)),
(CategoryTheory.Quotient.functor r).Additive | null | true |
Monotone.leftLim_le | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β},
Monotone f → ∀ {x y : α}, x ≤ y → Function.leftLim f x ≤ f y | null | true |
ContinuousAlternatingMap.piLinearEquiv._proof_4 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {A : Type u_1} {M : Type u_2} {ι : Type u_4} [inst : Semiring A] [inst_1 : AddCommMonoid M]
[inst_2 : TopologicalSpace M] [inst_3 : Module A M] {ι' : Type u_5} {M' : ι' → Type u_3}
[inst_4 : (i : ι') → AddCommMonoid (M' i)] [inst_5 : (i : ι') → TopologicalSpace (M' i)]
[inst_6 : ∀ (i : ι'), ContinuousAdd (M' i)... | null | false |
Field.toSemifield._proof_1 | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_1} [inst : Field K] (a b : K), a * b = b * a | null | false |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip₀₁'._simp_1_6 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
BiheytingHom.comp_apply | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β]
[inst_2 : BiheytingAlgebra γ] (f : BiheytingHom β γ) (g : BiheytingHom α β) (a : α), (f.comp g) a = f (g a) | null | true |
instContinuousConstSMulMatrix | Mathlib.Topology.Instances.Matrix | ∀ {α : Type u_2} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : SMul α R]
[ContinuousConstSMul α R], ContinuousConstSMul α (Matrix m n R) | null | true |
ValuativeRel.IsRankLeOne | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | (R : Type u_1) → [inst : Semiring R] → [ValuativeRel R] → Prop | We say that a ring with a valuative relation is of rank one if
there exists a strictly monotone embedding of the "canonical" value group-with-zero into
the nonnegative reals, and the image of this embedding contains some element different
from `0` and `1`. | true |
LocallyFiniteOrder.orderAddMonoidHom.congr_simp | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ (G : Type u_2) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
[inst_3 : LocallyFiniteOrder G], LocallyFiniteOrder.orderAddMonoidHom G = LocallyFiniteOrder.orderAddMonoidHom G | null | true |
CategoryTheory.Limits.HasBiproduct.of_hasProduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
[Finite J] (f : J → C) [CategoryTheory.Limits.HasProduct f], CategoryTheory.Limits.HasBiproduct f | In a preadditive category, if the product over `f : J → C` exists,
then the biproduct over `f` exists. | true |
QuadraticMap.Isometry.proj_apply | Mathlib.LinearAlgebra.QuadraticForm.Prod | ∀ {ι : Type u_1} {R : Type u_2} {P : Type u_7} {Mᵢ : ι → Type u_8} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (Mᵢ i)] [inst_2 : AddCommMonoid P] [inst_3 : (i : ι) → Module R (Mᵢ i)]
[inst_4 : Module R P] [inst_5 : Fintype ι] [inst_6 : DecidableEq ι] (i : ι) (Q : QuadraticMap R (Mᵢ i) P)
(f : (x : ι... | null | true |
_private.Aesop.Tree.AddRapp.0.Aesop.copyGoals.match_1 | Aesop.Tree.AddRapp | (motive : Aesop.ForwardState × Aesop.ForwardRuleMatches × Aesop.UnorderedArraySet Lean.MVarId → Sort u_1) →
(__discr : Aesop.ForwardState × Aesop.ForwardRuleMatches × Aesop.UnorderedArraySet Lean.MVarId) →
((forwardState : Aesop.ForwardState) →
(forwardRuleMatches : Aesop.ForwardRuleMatches) →
(... | null | false |
Lean.LevelMetavarDecl | Lean.MetavarContext | Type | null | true |
BitVec.setWidth_eq_append_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {v : ℕ} {x : BitVec v} {w : ℕ}, BitVec.setWidth w x = BitVec.cast ⋯ (0#(w - v) ++ BitVec.extractLsb' 0 (min v w) x) | A `(x : BitVec v)` set to width `w` equals `(v - w)` zeros,
followed by the low `(min v w) bits of `x`
| true |
CompactlySupportedContinuousMap.coe_inf._simp_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SemilatticeInf β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] [inst_4 : ContinuousInf β] (f g : CompactlySupportedContinuousMap α β),
⇑f ⊓ ⇑g = ⇑(f ⊓ g) | null | false |
List.Nodup.product | Mathlib.Data.List.Nodup | ∀ {α : Type u} {β : Type v} {l₁ : List α} {l₂ : List β}, l₁.Nodup → l₂.Nodup → (l₁ ×ˢ l₂).Nodup | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk'._proof_4 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {C : Type u_2} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) (x : B),
CategoryTheory.CategoryStruct.id (S.obj x) = S.map (CategoryTheory.CategoryStruct.id x) | null | false |
LinearMap.BilinForm.IsAlt.ortho_comm | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R₁ : Type u_3} {M₁ : Type u_4} [inst : CommRing R₁] [inst_1 : AddCommGroup M₁] [inst_2 : Module R₁ M₁]
{B₁ : LinearMap.BilinForm R₁ M₁}, B₁.IsAlt → ∀ {x y : M₁}, B₁.IsOrtho x y ↔ B₁.IsOrtho y x | null | true |
Int.gcd.eq_1 | Init.Data.Int.Linear | ∀ (m n : ℤ), m.gcd n = m.natAbs.gcd n.natAbs | null | true |
map_ratCast_smul | Mathlib.Algebra.Module.Rat | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] {F : Type u_3}
[inst_2 : FunLike F M M₂] [AddMonoidHomClass F M M₂] (f : F) (R : Type u_4) (S : Type u_5) [inst_4 : DivisionRing R]
[inst_5 : DivisionRing S] [inst_6 : Module R M] [inst_7 : Module S M₂] (c : ℚ) (x : M), f (↑c • x) =... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.printEqns._regBuiltin.Lean.Parser.Command.printEqns_1 | Lean.Parser.Command | IO Unit | null | false |
CategoryTheory.BiconeHom.decidableEq._proof_4 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) (j : J),
CategoryTheory.Bicone.left = CategoryTheory.Bicone.diagram j →
Bool.rec False True (CategoryTheory.Bicone.left.ctorIdx.beq (CategoryTheory.Bicone.diagram j).ctorIdx) | null | false |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_or_lt_of_ne._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | null | false |
ContinuousMultilinearMap.opNorm_neg | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E G), ‖... | null | true |
Std.ExtTreeSet.isEmpty_insertMany_list | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {l : List α},
(t.insertMany l).isEmpty = (t.isEmpty && l.isEmpty) | null | true |
UpperHalfPlane.instIsPretransitiveGeneralLinearGroupFinOfNatNatReal | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | MulAction.IsPretransitive (GL (Fin 2) ℝ) UpperHalfPlane | null | true |
CategoryTheory.ULiftHom.equiv._proof_1 | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (x : C),
(CategoryTheory.Functor.id C).obj x = (CategoryTheory.Functor.id C).obj x | null | false |
_private.Mathlib.CategoryTheory.Limits.IndYoneda.0.CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π._simp_1_2 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
sInfHom.dual_apply_toFun | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] (f : sInfHom α β) (a : αᵒᵈ),
(sInfHom.dual f) a = (⇑OrderDual.toDual ∘ ⇑f ∘ ⇑OrderDual.ofDual) a | null | true |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic._aux_Batteries_Tactic_Trans___elabRules_Batteries_Tactic_tacticTrans____1.match_1 | Batteries.Tactic.Trans | (motive : Option (Lean.Expr × List Lean.MVarId) → Sort u_1) →
(t'? : Option (Lean.Expr × List Lean.MVarId)) →
((fst : Lean.Expr) → (gs' : List Lean.MVarId) → motive (some (fst, gs'))) →
((x : Option (Lean.Expr × List Lean.MVarId)) → motive x) → motive t'? | null | false |
Std.Time.Database.WindowsDb.default | Std.Time.Zoned.Database.Windows | Std.Time.Database.WindowsDb | Returns a default `WindowsDb` instance.
| true |
Lean.Parser.ModuleParserState.noConfusionType | Lean.Parser.Module | Sort u → Lean.Parser.ModuleParserState → Lean.Parser.ModuleParserState → Sort u | null | false |
Submodule.mem_span_set' | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m ∈ Submodule.span R s ↔ ∃ n f g, ∑ i, f i • ↑(g i) = m | An element `m ∈ M` is contained in the `R`-submodule spanned by a set `s ⊆ M`, if and only if
`m` can be written as a finite `R`-linear combination of elements of `s`.
The implementation uses a sum indexed by `Fin n` for some `n`. | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_σ_comp_of_not_injective._proof_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} (x y : Fin (n + 1 + 1)), ¬x = y → ¬x < y → y < x | null | false |
FGModuleCat.instCreatesColimitsOfShapeModuleCatForget₂LinearMapIdCarrierObjIsFG | Mathlib.Algebra.Category.FGModuleCat.Colimits | {J : Type} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.FinCategory J] →
{k : Type u} →
[inst_2 : Ring k] →
CategoryTheory.CreatesColimitsOfShape J (CategoryTheory.forget₂ (FGModuleCat k) (ModuleCat k)) | null | true |
Std.DHashMap.Internal.AssocList.getKey._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
(a : α) → (l : Std.DHashMap.Internal.AssocList α β) → Std.DHashMap.Internal.AssocList.contains a l = true → α | null | false |
Std.Do.Spec.pure | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps] {α : Type u} {a : α}
{Q : Std.Do.PostCond α ps}, ⦃Q.1 a⦄ pure a ⦃Q⦄ | null | true |
MulOpposite.instNatCast | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [NatCast R] → NatCast Rᵐᵒᵖ | null | true |
Lean.Parser.FirstTokens.tokens.inj | Lean.Parser.Types | ∀ {a a_1 : List Lean.Parser.Token}, Lean.Parser.FirstTokens.tokens a = Lean.Parser.FirstTokens.tokens a_1 → a = a_1 | null | true |
Lean.Elab.DelabTermInfo.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → Lean.Elab.DelabTermInfo → Lean.Elab.DelabTermInfo → Sort u | null | false |
Nat.a_eq_digitChar | Init.Data.Nat.ToString | ∀ {n : ℕ}, 'a' = n.digitChar ↔ n = 10 | null | true |
Finset.instMulLeftMono | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α], MulLeftMono (Finset α) | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq.0.Lean.Meta.Grind.Arith.Linear.updateDiseqs | Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq | ℤ →
Lean.Grind.Linarith.Var →
Lean.Meta.Grind.Arith.Linear.EqCnstr → Lean.Grind.Linarith.Var → Lean.Meta.Grind.Arith.Linear.LinearM Unit | null | true |
_private.Mathlib.Topology.Order.MonotoneContinuity.0.continuousWithinAt_left_of_monotoneOn_of_exists_between.match_1_1 | Mathlib.Topology.Order.MonotoneContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder β] {f : α → β} {s : Set α} {a : α} (b : βᵒᵈ)
(motive : (∃ c ∈ s, f c ∈ Set.Ioo b (f a)) → Prop) (x : ∃ c ∈ s, f c ∈ Set.Ioo b (f a)),
(∀ (c : α) (hcs : c ∈ s) (hcb : b < f c) (hca : f c < f a), motive ⋯) → motive x | null | false |
Batteries.BinomialHeap.Imp.Heap.merge._unary._proof_3 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (s₁ : Batteries.BinomialHeap.Imp.Heap α) (r₁ : ℕ) (a₁ : α) (n₁ : Batteries.BinomialHeap.Imp.HeapNode α)
(t₁ : Batteries.BinomialHeap.Imp.Heap α) (h : s₁ = Batteries.BinomialHeap.Imp.Heap.cons r₁ a₁ n₁ t₁)
(s₂ : Batteries.BinomialHeap.Imp.Heap α) (r₂ : ℕ) (a₂ : α) (n₂ : Batteries.BinomialHeap.Imp.He... | null | false |
_private.Mathlib.Algebra.Ring.SumsOfSquares.0.Subsemiring.closure_isSquare._simp_1_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {T : Type u_2} [inst : CommSemiring T], Subsemiring.closure {x | IsSquare x} = (Submonoid.square T).subsemiringClosure | null | false |
instSemiringCorner._proof_5 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalSemiring R] (idem : IsIdempotentElem e) (r : idem.Corner), r * 1 = r | null | false |
AffineEquiv.linearHom._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (x x_1 : P₁ ≃ᵃ[k] P₁), (x * x_1).linear = (x * x_1).linear | null | false |
instContMDiffSMulContinuousLinearMapIdModelWithCornersSelfOfCompleteSpace | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [CompleteSpace E] {n : WithTop ℕ∞},
ContMDiffSMul (modelWithCornersSelf 𝕜 (E →L[𝕜] E)) (modelWithCornersSelf 𝕜 E) n (E →L[𝕜] E) E | The monoid `E →L[𝕜] E` of continuous linear endomorphisms of `E` acts smoothly on `E`. | true |
RBTree.RBNode.All.upperBound?_ub | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {p : α → Prop} {ub : Option α} {cut : α → Ordering} {x : α} {t : RBTree.RBNode α},
RBTree.RBNode.All p t → (∀ {x : α}, ub = some x → p x) → RBTree.RBNode.upperBound? cut t ub = some x → p x | null | true |
NonemptyFinLinOrd.hasForgetToLinOrd._proof_3 | Mathlib.Order.Category.NonemptyFinLinOrd | autoParam
(NonemptyFinLinOrd.hasForgetToLinOrd._aux_1.comp (CategoryTheory.forget LinOrd) =
CategoryTheory.forget NonemptyFinLinOrd)
CategoryTheory.HasForget₂.forget_comp._autoParam | null | false |
_private.Init.Data.String.Lemmas.Intercalate.0.String.intercalate.go.match_1.eq_2 | Init.Data.String.Lemmas.Intercalate | ∀ (motive : List String → Sort u_1) (h_1 : (a : String) → (as : List String) → motive (a :: as))
(h_2 : Unit → motive []),
(match [] with
| a :: as => h_1 a as
| [] => h_2 ()) =
h_2 () | null | true |
minpoly.natSepDegree_eq_one_iff_eq_expand_X_sub_C | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Ring E] [IsDomain E] [inst_3 : Algebra F E] (q : ℕ)
[hF : ExpChar F q] {x : E},
(minpoly F x).natSepDegree = 1 ↔ ∃ n y, minpoly F x = (Polynomial.expand F (q ^ n)) (Polynomial.X - Polynomial.C y) | The minimal polynomial of an element of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`Polynomial.expand F (q ^ n) (X - C y)` for some `n : ℕ` and `y : F`. | true |
Lean.AddErrorMessageContext.casesOn | Lean.Exception | {m : Type → Type} →
{motive : Lean.AddErrorMessageContext m → Sort u} →
(t : Lean.AddErrorMessageContext m) →
((add : Lean.Syntax → Lean.MessageData → m (Lean.Syntax × Lean.MessageData)) → motive { add := add }) → motive t | null | false |
Pi.constRingHom._proof_4 | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonAssocSemiring β] (x y : β),
(↑↑(RingHom.pi fun x => RingHom.id β)).toFun (x + y) =
(↑↑(RingHom.pi fun x => RingHom.id β)).toFun x + (↑↑(RingHom.pi fun x => RingHom.id β)).toFun y | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.vectorSpan_add_self._proof_1_3 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_2) {V : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] (s : Set V) (x : V),
(∃ x_1 ∈ vectorSpan k s, ∃ y ∈ s, x_1 + y = x) ↔ ∃ p₁ ∈ s, ∃ v ∈ vectorSpan k s, x = v + p₁ | null | false |
InfHom.dual._proof_3 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : Min β] (f : SupHom αᵒᵈ βᵒᵈ) (a b : αᵒᵈ),
f.toFun (a ⊔ b) = f.toFun a ⊔ f.toFun b | null | false |
Submonoid.powers._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] (n n_1 : M) (i : ℕ), (fun x => n ^ x) i = n_1 ↔ ((powersHom M) n) i = n_1 | null | false |
LowerSet.erase_lt._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {a : α}, (s.erase a < s) = (a ∈ s) | null | false |
CochainComplex.shiftEval_inv_app | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n i i' : ℤ)
(hi : n + i = i') (X : CochainComplex C ℤ),
(CochainComplex.shiftEval C n i i' hi).inv.app X = (HomologicalComplex.XIsoOfEq X ⋯).inv | null | true |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.ne_singleton_iff._simp_1_2 | Mathlib.Data.List.Nodup | ∀ {a b c : Prop}, (a ∧ (b ∨ c)) = (a ∧ b ∨ a ∧ c) | null | false |
Std.ExtDHashMap.containsThenInsert.congr_simp | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtDHashMap α β),
m = m_1 → ∀ (a : α) (b b_1 : β a), b = b_1 → m.containsThenInsert a b = m_1.containsThenInsert a b_1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.