name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_12 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k + 1 < ↑j → ↑k < ↑j → ¬↑k < ↑i → ↑k + 1 + 1 = ↑k + 1 | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic.0.tacticEval_simp | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | Lean.ParserDescr | null | true |
IsPrimitiveRoot.idealQuotient_mk | Mathlib.NumberTheory.NumberField.Ideal.Basic | ∀ {K : Type u_1} [inst : Field K] {I : Ideal (NumberField.RingOfIntegers K)} [inst_1 : NumberField K] {n : ℕ} [NeZero n]
{ζ : NumberField.RingOfIntegers K},
IsPrimitiveRoot ζ n → Ideal.absNorm I ≠ 1 → (Ideal.absNorm I).Coprime n → IsPrimitiveRoot ((Ideal.Quotient.mk I) ζ) n | null | true |
Stream'.WSeq.ofList_cons | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (a : α) (l : List α), ↑(a :: l) = Stream'.WSeq.cons a ↑l | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_zero_one_two_three_four_iff._simp_1_1 | Mathlib.NumberTheory.Divisors | ∀ {x y z : ℤ}, z ≠ 0 → (x * y = z) = ((x, y) ∈ z.divisorsAntidiag) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap.0.WeierstrassCurve.addSubMapCoeff._proof_13 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | (47 + 1).AtLeastTwo | null | false |
CategoryTheory.Limits.exists_eq_isColimitMap_of_preservesColimit_coyoneda | Mathlib.CategoryTheory.Limits.ConstructLimitMap | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {I : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} I]
{I' : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} I'] {D : CategoryTheory.Functor I C}
{D' : CategoryTheory.Functor I' C} {c : CategoryTheory.Limits.Cocone D} {c' : CategoryTheory.Limits.C... | A morphism `f` between filtered colimits, where every object of the source diagram is
presentable relative to the target diagram, is finally induced by a natural transformation of
diagrams.is induced by a natural transformation of diagrams. | true |
CompareReals.compareEquiv | Mathlib.Topology.UniformSpace.CompareReals | CompareReals.Bourbakiℝ ≃ᵤ ℝ | The uniform bijection between Bourbaki and Cauchy reals. | true |
Lean.Options.getInPattern | Lean.Data.Options | Lean.Options → Bool | null | true |
StandardEtalePair.instEtaleRing | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R), Algebra.Etale R P.Ring | null | true |
CategoryTheory.Equivalence.counitInv.eq_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D), e.counitInv = e.counitIso.inv | null | true |
SimpleGraph.Walk.isPath_transfer | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {H : SimpleGraph V} {p : G.Walk u v} (h : ∀ e ∈ p.edges, e ∈ H.edgeSet),
(p.transfer H h).IsPath ↔ p.IsPath | null | true |
MulSemiringActionHom.map_mul' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_10} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_12} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S]
(self : R →ₑ+*[φ] S) (x y : R), self.toFun (x * y) = self.toFun x * self.toFun y | The proposition that the function preserves multiplication | true |
WithCStarModule.instNormedAddCommGroupProd._proof_18 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
(x : WithCStarModule A (E × F)),
nhds x =
Filter.comap (Prod.mk x)
(Filter.comap (fun p => ((WithCStarModule.equiv A (E × F)) p.1, (WithCStarModule.equiv A (E × F)) p.2))
(uniformity (E × F... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceFrom_ne_startPos._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} (p : s.Pos), (p ≠ s.startPos) = (s.startPos < p) | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchAt?_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt c pos pos' =
∃ (h : pos' ≠ s.startPos), pos = pos'.prev h ∧ (pos'.prev h).get ⋯ = c | null | false |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.MvPolynomial.schwartz_zippel_sup_sum._simp_1_5 | Mathlib.Algebra.MvPolynomial.SchwartzZippel | ∀ {a b c d : Prop}, ((a ∧ b) ∧ c ∧ d) = ((a ∧ c) ∧ b ∧ d) | null | false |
NonUnitalStarAlgHom.mk | Mathlib.Algebra.Star.StarAlgHom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : DistribMulAction R B] →
... | null | true |
SSet.prodStdSimplex.pairingCore.IsType₂.simplex.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x x_1 : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
(e_x : x = x_1) (hx : SSet.prodStdSimplex.pairingCore.IsType₂ x) {d : ℕ} (hd : x.dim = d), hx.simplex hd = ⋯.simplex ⋯ | null | true |
ContinuousOrderHom._sizeOf_inst | Mathlib.Topology.Order.Hom.Basic | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : TopologicalSpace α} → {inst_3 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →Co β) | null | false |
Std.DTreeMap.isEmpty_toList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.toList.isEmpty = t.isEmpty | null | true |
HahnModule.instAddCommGroup._proof_9 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommGroup V],
autoParam (∀ (n : ℕ) (a : HahnModule Γ R V), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.toTriangle._simp_5 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
ImportGraph.Shake.Needs.HighToLow._sizeOf_inst | ImportGraph.Shake.Basic | SizeOf ImportGraph.Shake.Needs.HighToLow | null | false |
Real.geom_mean_le_arith_mean3_weighted | Mathlib.Analysis.MeanInequalities | ∀ {w₁ w₂ w₃ p₁ p₂ p₃ : ℝ},
0 ≤ w₁ →
0 ≤ w₂ →
0 ≤ w₃ → 0 ≤ p₁ → 0 ≤ p₂ → 0 ≤ p₃ → w₁ + w₂ + w₃ = 1 → p₁ ^ w₁ * p₂ ^ w₂ * p₃ ^ w₃ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ | null | true |
AddMonCat.HasLimits.limitConeIsLimit._proof_5 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat)
(s : CategoryTheory.Limits.Cone F) (x y : ↑s.1) {j j' : J} (f : j ⟶ j'),
(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget AddMonCat).mapCone s).π.app j)
... | null | false |
AddMonoidHom.mulOp._proof_4 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (x y : Mᵐᵒᵖ),
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) (x + y) =
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) x + (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) y | null | false |
CategoryTheory.comp_eqToHom_iff | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y'),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom p) = g ↔
f = CategoryTheory.CategoryStruct.comp g (CategoryTheory.eqToHom ⋯) | null | true |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.foundLine | Init.Data.Format.Basic | Std.Format.SpaceResult✝ → Bool | null | true |
Ordinal.isNormal_veblen_zero | Mathlib.SetTheory.Ordinal.Veblen | Order.IsNormal fun x => Ordinal.veblen x 0 | null | true |
instContinuousSMulTangentSpace | Mathlib.Geometry.Manifold.IsManifold.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] (_x : M), ContinuousSMul 𝕜 (TangentSpa... | null | true |
Cardinal.lift_sSup | Mathlib.SetTheory.Cardinal.Basic | ∀ {s : Set Cardinal.{u_1}}, BddAbove s → Cardinal.lift.{u, u_1} (sSup s) = sSup (Cardinal.lift.{u, u_1} '' s) | The lift of a supremum is the supremum of the lifts. | true |
_private.Mathlib.Order.ModularLattice.0.strictMono_inf_prod_sup.match_1_1 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : Lattice α] {z : α} (_x _y : α)
(motive : (fun x => (x ⊓ z, x ⊔ z)) _y ≤ (fun x => (x ⊓ z, x ⊔ z)) _x → Prop)
(x : (fun x => (x ⊓ z, x ⊔ z)) _y ≤ (fun x => (x ⊓ z, x ⊔ z)) _x),
(∀ (inf_le : ((fun x => (x ⊓ z, x ⊔ z)) _y).1 ≤ ((fun x => (x ⊓ z, x ⊔ z)) _x).1)
(sup_le : ((fun x => (x ⊓... | null | false |
Lean.Parser.Term.letOpts.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
LieAlgebra.SemiDirectSum.inl | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (ψ : L →ₗ⁅R⁆ LieDerivation R K K) → K →ₗ⁅R⁆ K ⋊⁅ψ⁆ L | The canonical inclusion of K into the semi-direct sum K ⋊⁅ψ⁆ G. | true |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage | Mathlib.RingTheory.AdicCompletion.Exactness | {R : Type u} →
[inst : CommRing R] →
{I : Ideal R} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{N : Type w} →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{f : M →ₗ[R] N} →
Funct... | Inductively construct preimage of Cauchy sequence. | true |
CategoryTheory.Cat.equivOfIso._proof_3 | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} (γ : C ≅ D), γ.inv.toFunctor.comp γ.hom.toFunctor = CategoryTheory.Functor.id ↑D | null | false |
Finsupp.subtypeDomain_sub | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {G : Type u_8} [inst : AddGroup G] {p : α → Prop} {v v' : α →₀ G},
Finsupp.subtypeDomain p (v - v') = Finsupp.subtypeDomain p v - Finsupp.subtypeDomain p v' | null | true |
Std.HashMap.Raw.WF.filterMap | Std.Data.HashMap.AdditionalOperations | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β}
{f : α → β → Option γ}, m.WF → (Std.HashMap.Raw.filterMap f m).WF | null | true |
RBTree.RBNode.Slow.instDecidableOrdered._unsafe_rec | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
(cmp : α → α → Ordering) → [Std.TransCmp cmp] → (t : RBTree.RBNode α) → Decidable (RBTree.RBNode.Ordered cmp t) | null | false |
Std.TreeMap.getKey_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{hc : t.minKey! ∈ t}, t.getKey t.minKey! hc = t.minKey! | null | true |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.bindMutVarsFromTuple.go._sunfold | Lean.Elab.Do.Basic | List Lean.Name →
Lean.FVarId → Lean.Expr → Array Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr | null | false |
MonoidHom.toOneHom_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N] (f : M →* N), ⇑↑f = ⇑f | null | true |
IsAddUnit.add_right_cancel | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M] {a b c : M}, IsAddUnit b → a + b = c + b → a = c | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.ofArray.go._unsafe_rec | Batteries.Data.MLList.Basic | {m : Type → Type} → {α : Type} → Array α → ℕ → MLList m α | null | false |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.isMulCommutative_iSup._simp_1_3 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
OrderDual.ofDual_le_ofDual | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [inst : LE α] {a b : αᵒᵈ}, OrderDual.ofDual a ≤ OrderDual.ofDual b ↔ b ≤ a | null | true |
List.append_eq | Init.Data.List.Basic | ∀ {α : Type u} {as bs : List α}, as.append bs = as ++ bs | null | true |
fderivWithin_of_mem_nhds | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s : Set E}, s ∈ nhds x → fderivWithin 𝕜 f s x = fder... | null | true |
RingHom.Finite.finiteType | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] {f : A →+* B}, f.Finite → f.FiniteType | null | true |
_private.Mathlib.Algebra.DirectSum.Internal.0.listProd_apply_eq_zero._simp_1_2 | Mathlib.Algebra.DirectSum.Internal | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
Complex.regularizedHGFun_zero_singleton_neg_nat_add_one | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ (n : ℕ) (z : ℂ), Complex.regularizedHGFun 0 {-↑n + 1} z = z ^ n * Complex.regularizedHGFun 0 {↑n + 1} z | null | true |
_private.Mathlib.GroupTheory.Coset.Basic.0.Subgroup.quotientiInfSubgroupOfEmbedding._simp_3 | Mathlib.GroupTheory.Coset.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : ↥K}, (h ∈ H.subgroupOf K) = (↑h ∈ H) | null | false |
_private.Mathlib.AlgebraicGeometry.Cover.Sigma.0.AlgebraicGeometry.Scheme.Cover.presieve₀_sigma.match_1_1 | Mathlib.AlgebraicGeometry.Cover.Sigma | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : UnivLE.{u_2, u_1}]
{S : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S)
(motive :
(T : AlgebraicGeometry.Scheme) →
(g : T ⟶ S) → CategoryTheory.Presieve.singleton (CategoryTh... | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkSize.go.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_fst_toList_eq_keys._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Std.DHashMap.Raw.Const.get?_inter_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → Std.DHashMap.Raw.Const.get? (m₁ ∩ m₂) k = none | null | true |
_private.Mathlib.Algebra.Module.TransferInstance.0.AddEquiv.linearEquiv._simp_1 | Mathlib.Algebra.Module.TransferInstance | ∀ {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [inst : FunLike F α β] [i : EmbeddingLike F α β] (f : F) {x y : α},
(f x = f y) = (x = y) | null | false |
Subalgebra.perfectClosure | Mathlib.FieldTheory.PurelyInseparable.Basic | (R : Type u_1) →
(A : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] → [inst_2 : Algebra R A] → (p : ℕ) → [ExpChar A p] → Subalgebra R A | The perfect closure of `R` in `A` are the elements `x : A` such that `x ^ p ^ n`
is in `R` for some `n`, where `p` is the exponential characteristic of `R`. | true |
_private.Mathlib.Geometry.Convex.Cone.Face.Basic.0.PointedCone.IsFaceOf.fst._simp_1_2 | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
Int.modEq_sub_modulus_mul_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a ≡ b - n * c [ZMOD n] ↔ a ≡ b [ZMOD n] | null | true |
ProbabilityTheory.Kernel.iIndepFun.comp₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8} {γ : ι → Type u_9}
{mβ : (i : ι) → MeasurableSpace (β i)} {mγ : (i : ι) → MeasurableSpace (γ i)} {f : (i : ι) → Ω → β i},
Probability... | null | true |
Submodule.map._proof_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_2} {M₂ : Type u_1} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[RingHomSurjective σ₁₂] (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) (c : R₂) {x : M₂}, x ∈ ⇑f '... | null | false |
Std.Do.Spec.forIn'_list._proof_5 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : List α}, xs ++ [] = xs | null | false |
Std.TreeMap.Raw.minKeyD_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β} {fallback : α},
(t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | null | true |
hasFDerivWithinAt_pi' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i}
{Φ' : E →L[𝕜] ... | null | true |
Functor.map_unit | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} [inst : Functor f] [LawfulFunctor f] {a : f PUnit.{u_1 + 1}},
(fun x => PUnit.unit) <$> a = a | null | true |
Sym.filterNe._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (m : Sym α n), (↑m).card < n + 1 | null | false |
Lean.IR.Expr.proj.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) → t.ctorIdx = 3 → ((i : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.proj i x)) → motive t | null | false |
SkewMonoidAlgebra.noConfusion | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {P : Sort u} →
{k : Type u_1} →
{G : Type u_2} →
{inst : Zero k} →
{t : SkewMonoidAlgebra k G} →
{k' : Type u_1} →
{G' : Type u_2} →
{inst' : Zero k'} →
{t' : SkewMonoidAlgebra k' G'} →
k = k' → G = G' → inst ≍ inst' → t ≍ t' → Sk... | null | false |
Vector.getElem?_append_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m i : ℕ} {xs : Vector α n} {ys : Vector α m}, n ≤ i → (xs ++ ys)[i]? = ys[i - n]? | null | true |
AlgebraicGeometry.Scheme.affineOverMk | Mathlib.AlgebraicGeometry.Sites.Affine | {S : AlgebraicGeometry.Scheme} →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{R : CommRingCat} → (f : AlgebraicGeometry.Spec R ⟶ S) → P f → P.CostructuredArrow ⊤ AlgebraicGeometry.Scheme.Spec S | Construct an object of affine `P`-schemes over `S` by giving a morphism `Spec R ⟶ S`. | true |
Lean.Level.collectMVars | Lean.Level | Lean.Level → optParam Lean.LMVarIdSet ∅ → Lean.LMVarIdSet | null | true |
Lean.LLVM.IntPredicate.noConfusionType | Lean.Compiler.IR.LLVMBindings | Sort u → Lean.LLVM.IntPredicate → Lean.LLVM.IntPredicate → Sort u | null | false |
NormedAddTorsor | Mathlib.Analysis.Normed.Group.AddTorsor | (V : outParam (Type u_1)) → (P : Type u_2) → [SeminormedAddCommGroup V] → [PseudoMetricSpace P] → Type (max u_1 u_2) | A `NormedAddTorsor V P` is a torsor of an additive seminormed group
action by a `SeminormedAddCommGroup V` on points `P`. We bundle the pseudometric space
structure and require the distance to be the same as results from the
norm (which in fact implies the distance yields a pseudometric space, but
bundling just the dis... | true |
SubMulAction.instSMulSubtypeMem._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : SMul R M] (p : SubMulAction R M) (c : R) (x : ↥p), c • ↑x ∈ p | null | false |
ωCPO._sizeOf_1 | Mathlib.Order.Category.OmegaCompletePartialOrder | ωCPO → ℕ | null | false |
IsAlgebraic.smul | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → ∀ (r : R), IsAlgebraic R (r • a) | null | true |
Quiver.Path.nil | Mathlib.Combinatorics.Quiver.Path | {V : Type u} → [inst : Quiver V] → {a : V} → Quiver.Path a a | null | true |
_private.Init.Data.List.Impl.0.List.zipWith_eq_zipWithTR.go | Init.Data.List.Impl | ∀ (α : Type u_3) (β : Type u_2) (γ : Type u_1) (f : α → β → γ) (as : List α) (bs : List β) (acc : Array γ),
List.zipWithTR.go✝ f as bs acc = acc.toList ++ List.zipWith f as bs | null | true |
WeierstrassCurve.Projective.Point.mk.inj | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} {inst : CommRing R} {W' : WeierstrassCurve.Projective R}
{point : WeierstrassCurve.Projective.PointClass R} {nonsingular : W'.NonsingularLift point}
{point_1 : WeierstrassCurve.Projective.PointClass R} {nonsingular_1 : W'.NonsingularLift point_1},
{ point := point, nonsingular := nonsingular } = { ... | null | true |
LinearMap.IsIdempotentElem.isSymmetric_iff_isOrtho_range_ker | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E}, IsIdempotentElem T → (T.IsSymmetric ↔ T.range ⟂ T.ker) | An idempotent operator is symmetric if and only if its range is
pairwise orthogonal to its kernel. | true |
dist_le_range_sum_dist | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] (f : ℕ → α) (n : ℕ),
dist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, dist (f i) (f (i + 1)) | The triangle (polygon) inequality for sequences of points; `Finset.range` version. | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.del.match_1.splitter | Batteries.Recycling.RBTree.Lemmas | (motive : RBTree.RBColor → Sort u_1) →
(x : RBTree.RBColor) → (Unit → motive RBTree.RBColor.black) → (Unit → motive RBTree.RBColor.red) → motive x | null | true |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_inst | Mathlib.Tactic.FunProp.Theorems | SizeOf Mathlib.Meta.FunProp.LambdaTheorems | null | false |
CStarMatrix.ofMatrixRingEquiv._proof_2 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : Semiring A] (x x_1 : Matrix n n A),
CStarMatrix.ofMatrix.toFun (x + x_1) = CStarMatrix.ofMatrix.toFun (x + x_1) | null | false |
PiTensorProduct.mapMultilinear_apply | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} (R : Type u_4) [inst : CommSemiring R] (s : ι → Type u_7) [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (t : ι → Type u_11) [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i →ₗ[R] t i),
(PiTensorProduct.mapMultilinear R ... | null | true |
ImportGraph.Lake.PackageSummary.rec | ImportGraph.WorkspaceModel.Summary.Core | {motive : ImportGraph.Lake.PackageSummary → Sort u} →
((toBasePackage : ImportGraph.Lake.BasePackage) →
(deps : Array ℕ) →
(libs : Array ImportGraph.Lake.LibrarySummary) →
(configFile : System.FilePath) →
motive { toBasePackage := toBasePackage, deps := deps, libs := libs, configFi... | null | false |
«term_=_» | Init.Notation | Lean.TrailingParserDescr | The equality relation. It has one introduction rule, `Eq.refl`.
We use `a = b` as notation for `Eq a b`.
A fundamental property of equality is that it is an equivalence relation.
```
variable (α : Type) (a b c d : α)
variable (hab : a = b) (hcb : c = b) (hcd : c = d)
example : a = d :=
Eq.trans (Eq.trans hab (Eq.sym... | true |
CategoryTheory.Over.prodLeftIsoPullback_hom_fst_assoc | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.Limits.HasPullback Y.hom Z.hom] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
{Z_1 : C} (h : Y.left ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Y.prodLeftIsoPullback Z).hom
(Catego... | null | true |
_private.Init.Data.List.Perm.0.List.reverse_perm.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (_ : Unit), motive []) → (∀ (a : α) (l : List α), motive (a :: l)) → motive x | null | false |
Matrix.det_of_mem_unitary | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
{A : Matrix n n α}, A ∈ Matrix.unitaryGroup n α → A.det ∈ unitary α | null | true |
instAB4AddCommGrpCat | Mathlib.Algebra.Category.Grp.AB | CategoryTheory.AB4 AddCommGrpCat | null | true |
ContinuousAt.lineMap | Mathlib.Topology.Algebra.Affine | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : Ring R]
[inst_6 : Module R V] [inst_7 : TopologicalSpace R] [ContinuousSMul R V] {X : Type u_6} [inst_9 : TopologicalSpace ... | null | true |
AddMonoidAlgebra.le_infDegree_mul | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
[inst_3 : AddZeroClass A] [inst_4 : Add T] [AddLeftMono T] [AddRightMono T] (D : A →ₙ+ T)
(f g : AddMonoidAlgebra R A),
AddMonoidAlgebra.infDegree (⇑D) f + AddMonoidAlgebra.infDegree (⇑D) g ≤ AddMo... | null | true |
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.1964439861._hygCtx._hyg.3 | Lean.Elab.Quotation | Lean.Elab.Term.TermElab | null | false |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.Polynomial.instFiniteUniversalFactorizationRing._proof_1 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
Module.Finite R (Polynomial.UniversalFactorizationRing m k hn p) | null | false |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_5 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a ≤ x ∧ x ≤ b → (x - a).toNat < (b + 1 - a).toNat ∧ a + ↑(x - a).toNat = x | null | false |
instCompleteLatticeStructureGroupoid._proof_7 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), b ≤ SemilatticeSup.sup a b | null | false |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_3 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (n₁ n₂ : ℕ), max n₁ n₂ + 1 + (max n₁ n₂ + 1) ≤ 2 * max n₁ n₂ + 1 + 1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.