name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.specializes_of_subset_closure._simp_1_1 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α}, s ⤳ t = ((∀ x ∈ s, ∃ y ∈ t, x ⤳ y) ∧ t ⊆ closure s) | null | false |
Lean.instHashableExtraModUse | Lean.ExtraModUses | Hashable Lean.ExtraModUse | null | true |
SSet.horn₃₂.desc.multicofork_π_one._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | 1 ∈ {2}ᶜ | null | false |
Matrix.diagonalLinearMap | Mathlib.Data.Matrix.Basic | (n : Type u_3) →
(R : Type u_4) →
(α : Type u_8) →
[DecidableEq n] →
[inst : Semiring R] → [inst_1 : AddCommMonoid α] → [inst_2 : Module R α] → (n → α) →ₗ[R] Matrix n n α | `Matrix.diagonal` as a `LinearMap`. | true |
Cardinal.preAleph_nat | Mathlib.SetTheory.Cardinal.Aleph | ∀ (n : ℕ), Cardinal.preAleph ↑n = ↑n | **Alias** of `Cardinal.preAleph_natCast`. | true |
FunLike.subNegMonoid | Mathlib.Algebra.Group.FunLike | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Add F] →
[inst_2 : Zero F] →
[inst_3 : SMul ℕ F] →
[inst_4 : Neg F] →
[inst_5 : Sub F] →
[inst_6 : SMul ℤ F] →
[inst_7 : Sub... | A `FunLike` type is a `SubNegMonoid` if `β` is a `SubNegMonoid`. | true |
MeasureTheory.diracProbaEquiv.eq_1 | Mathlib.MeasureTheory.Measure.DiracProba | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : OpensMeasurableSpace X]
[inst_3 : T0Space X],
MeasureTheory.diracProbaEquiv =
{ toFun := fun x => ⟨MeasureTheory.diracProba x, ⋯⟩, invFun := MeasureTheory.diracProbaInverse, left_inv := ⋯,
right_inv := ⋯ } | null | true |
ModuleCat.hom_smul | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R} {S : Type u_1} [inst_1 : Monoid S] [inst_2 : DistribMulAction S ↑N]
[inst_3 : SMulCommClass R S ↑N] (s : S) (f : M ⟶ N), ModuleCat.Hom.hom (s • f) = s • ModuleCat.Hom.hom f | null | true |
Aesop.BaseRuleSetMember.safeForwardRule.noConfusion | Aesop.RuleSet.Member | {P : Sort u} →
{r₁ : Aesop.ForwardRule} →
{r₂ : Aesop.SafeRule} →
{r₁' : Aesop.ForwardRule} →
{r₂' : Aesop.SafeRule} →
Aesop.BaseRuleSetMember.safeForwardRule r₁ r₂ = Aesop.BaseRuleSetMember.safeForwardRule r₁' r₂' →
(r₁ = r₁' → r₂ = r₂' → P) → P | null | false |
DiscreteQuotient.instSubsingletonQuotientTop | Mathlib.Topology.DiscreteQuotient | ∀ {X : Type u_2} [inst : TopologicalSpace X], Subsingleton (Quotient ⊤.toSetoid) | The quotient by `⊤ : DiscreteQuotient X` is a `Subsingleton`. | true |
Nat.Partrec.Code.evaln._unary._proof_2 | Mathlib.Computability.PartrecCode | ∀ (k : ℕ) (cf cg : Nat.Partrec.Code),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 ⟨k + 1, cf⟩
⟨k.succ, cf.pair cg⟩ | null | false |
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_divisors._simp_1_2 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.closure_singleton_one._simp_1_2 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] {x y : M}, (y ∈ Submonoid.closure {x}) = ∃ n, x ^ n = y | null | false |
CategoryTheory.Pseudofunctor.DescentData.comp_hom | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ D₃ : F.DescentData f} (φ : D₁ ⟶ D₂) (φ' : D₂ ⟶ D₃) (i : ι),
(CategoryTheory.CategoryStruct.comp φ φ').... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceTo_le_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos},
(q < String.Slice.Pos.ofSliceTo p) = ∃ (h : q ≤ p₀), p₀.sliceTo q h < p | null | false |
Algebra.WeaklyQuasiFiniteAt.comap_algEquiv | Mathlib.RingTheory.QuasiFinite.Weakly | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing T] [inst_4 : Algebra R T] (p : Ideal S) [inst_5 : p.IsPrime] [Algebra.WeaklyQuasiFiniteAt R p]
(f : T ≃ₐ[R] S), Algebra.WeaklyQuasiFiniteAt R (Ideal.comap f.toRingEquiv.toRingHom p) | By `infer_instance` for `Algebra.QuasiFiniteAt R p`. | true |
lowerSemicontinuousOn_iff_frequently | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : LinearOrder β] {f : α → β} {s : Set α},
LowerSemicontinuousOn f s ↔ ∀ x ∈ s, ∀ (y : β), (∃ᶠ (x' : α) in nhdsWithin x s, f x' ≤ y) → f x ≤ y | null | true |
MeasureTheory.SimpleFunc.coe_const | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (b : β),
⇑(MeasureTheory.SimpleFunc.const α b) = Function.const α b | null | true |
Structomorph.symm._proof_1 | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u_2} {M : Type u_3} {M' : Type u_1} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
[inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace M'] {G : StructureGroupoid H} [inst_4 : ChartedSpace H M']
(e : Structomorph G M M') (c : OpenPartialHomeomorph M' H) (c' : OpenPartialHomeomorph M H),
c... | null | false |
IsFundamentalDomain.AddQuotientMeasureEqMeasurePreimage_AddHaarMeasure | Mathlib.MeasureTheory.Measure.Haar.Quotient | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : TopologicalSpace G]
[IsTopologicalAddGroup G] [BorelSpace G] [PolishSpace G] {Γ : AddSubgroup G} [inst_6 : Γ.Normal] [T2Space (G ⧸ Γ)]
[SecondCountableTopology (G ⧸ Γ)] {μ : MeasureTheory.Measure (G ⧸ Γ)} [Countable ↥Γ] (ν : MeasureTheory.M... | Given a normal
subgroup `Γ` of an additive topological group `G` with Haar measure `μ`, which is also
right-invariant, and a finite volume fundamental domain `𝓕`, the quotient map to `G ⧸ Γ`,
properly normalized, satisfies `AddQuotientMeasureEqMeasurePreimage`. | true |
Lean.Omega.LinearCombo.recOn | Init.Omega.LinearCombo | {motive : Lean.Omega.LinearCombo → Sort u} →
(t : Lean.Omega.LinearCombo) →
((const : ℤ) → (coeffs : Lean.Omega.Coeffs) → motive { const := const, coeffs := coeffs }) → motive t | null | false |
AffineSubspace.coe_inclusion_apply | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] {S₁ S₂ : AffineSubspace k P₁} [inst_4 : Nonempty ↥S₁] (h : S₁ ≤ S₂) (x : ↥S₁),
↑((AffineSubspace.inclusion h) x) = ↑x | null | true |
EuclideanGeometry.Sphere.power.eq_1 | Mathlib.Geometry.Euclidean.Sphere.Power | ∀ {P : Type u_2} [inst : MetricSpace P] (s : EuclideanGeometry.Sphere P) (p : P),
s.power p = dist p s.center ^ 2 - s.radius ^ 2 | null | true |
CategoryTheory.HasSubobjectClassifier | Mathlib.CategoryTheory.Subobject.Classifier.Defs | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | A category `C` has a subobject classifier if there is at least one subobject classifier. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.Walk.exists_adj_adj_not_adj_ne._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} {p : G.Walk v w},
p.length = G.dist v w →
p.tail.tail.length < p.tail.length →
p.tail.length < p.length →
G.dist v w ≤ p.tail.tail.length + 1 →
G.Adj v (p.getVert 1) ∧ G.Adj (p.getVert 1) (p.getVert 2) ∧ ¬G.Adj v (p.getVert 2) ∧ ¬v = p.getVert... | null | false |
Lean.Grind.instCommRingUInt64 | Init.GrindInstances.Ring.UInt | Lean.Grind.CommRing UInt64 | null | true |
Std.Do.ExceptConds.and_elim_right | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} (x y : Std.Do.ExceptConds ps), (x ∧ₑ y).entails y | null | true |
InverseSystem.piLTLim | Mathlib.Order.DirectedInverseSystem | {ι : Type u_6} →
[inst : LinearOrder ι] →
{X : ι → Type u_7} →
{i : ι} → Order.IsSuccPrelimit i → InverseSystem.piLT X i ≃ ↑(InverseSystem.limit InverseSystem.piLTProj i) | If `i` is a limit in a well-ordered type indexing a family of types,
then `piLT X i` is the limit of all `piLT X j` for `j < i`. | true |
BitVec.toNat_ofNatClamp | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ}, (BitVec.ofNatClamp w n).toNat = min n (2 ^ w - 1) | null | true |
CategoryTheory.Comonad.ComonadicityInternal.counitFork | Mathlib.CategoryTheory.Monad.Comonadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
{adj : F ⊣ G} →
(A : adj.toComonad.Coalgebra) →
[Cat... | This is a fork which is helpful for establishing comonadicity: the morphism from this fork to
the Beck equalizer is the counit for the adjunction on the comparison functor.
| true |
CategoryTheory.ComposableArrows.IsComplex.cokerToKer'_fac_assoc | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)} (hS : S.IsComplex) (k : ℕ) (hk : k ≤ n)
(cc : CategoryTheory.Limits.CokernelCofork (S.map' k (k + 1) ⋯ ⋯))
(kf : CategoryTheory.Limits.KernelFo... | null | true |
CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence._proof_3 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} J] {K : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
{F : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cone F} {G : CategoryTheory.Functor K C}
{t : CategoryTheory.Limi... | null | false |
DirectSum.GNonUnitalNonAssocSemiring.noConfusion | Mathlib.Algebra.DirectSum.Ring | {P : Sort u} →
{ι : Type u_1} →
{A : ι → Type u_2} →
{inst : Add ι} →
{inst_1 : (i : ι) → AddCommMonoid (A i)} →
{t : DirectSum.GNonUnitalNonAssocSemiring A} →
{ι' : Type u_1} →
{A' : ι' → Type u_2} →
{inst' : Add ι'} →
{inst'_1 :... | null | false |
Profinite.NobelingProof.Nobeling_aux | Mathlib.Topology.Category.Profinite.Nobeling.Induction | ∀ {I : Type u} [inst : LinearOrder I] [WellFoundedLT I] {S : Profinite} {ι : ↑S.toTop → I → Bool},
Topology.IsClosedEmbedding ι → Module.Free ℤ (LocallyConstant ↑S.toTop ℤ) | Given a profinite set `S` and a closed embedding `S → (I → Bool)`, the `ℤ`-module
`LocallyConstant C ℤ` is free.
| true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.congrHash.goEq | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENodeMap → Lean.Expr → Lean.Expr → UInt64 | null | true |
_private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.coverToFun_surjective._proof_1_10 | Mathlib.Condensed.Light.Sequence | ∀ {S : Type u_2} {T : Type u_1} {X : Type u_3} (π : T → S × Option X) (σ : Option X → S → T) (t : T) (n : X),
σ (some n) (π t).1 ∈ InternalProjectivityProof.fibres✝ π σ | null | false |
Pi.Colex.instCompleteLinearOrderColexForall._proof_3 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedGT ι] (a b c : Colex ((i : ι) → α i)), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | null | false |
Lean.Elab.DecreasingBy.tactic | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.DecreasingBy → Lean.TSyntax `Lean.Parser.Tactic.tacticSeq | null | true |
MeasurableEquiv.coe_piCurry | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {ι : Type u_6} {κ : ι → Type u_7} (X : (i : ι) → κ i → Type u_8)
[inst : (i : ι) → (j : κ i) → MeasurableSpace (X i j)], ⇑(MeasurableEquiv.piCurry X) = Sigma.curry | null | true |
LocallyConstant.congr_arg | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (f : LocallyConstant X Y) {x y : X}, x = y → f x = f y | null | true |
Subring.mem_toSubsemiring | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s : Subring R} {x : R}, x ∈ s.toSubsemiring ↔ x ∈ s | null | true |
CategoryTheory.uliftYonedaIsoShrinkYoneda._proof_3 | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C], CategoryTheory.LocallySmall.{max u_1 u_2, u_1, u_3} C | null | false |
Vector.mem_toArray_iff._simp_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (xs : Vector α n), (a ∈ xs.toArray) = (a ∈ xs) | null | false |
Complex.cos_nat_mul_two_pi_add_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℕ), Complex.cos (↑n * (2 * ↑Real.pi) + ↑Real.pi) = -1 | null | true |
Finset.preimage_mul_left_one' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Group α] {a : α}, Finset.preimage 1 (fun x => a⁻¹ * x) ⋯ = {a} | null | true |
Lean.Grind.Linarith.Expr.denoteN.match_1 | Init.Grind.Module.NatModuleNorm | (motive : Lean.Grind.Linarith.Expr → Sort u_1) →
(x : Lean.Grind.Linarith.Expr) →
((a b : Lean.Grind.Linarith.Expr) → motive (a.sub b)) →
((a : Lean.Grind.Linarith.Expr) → motive a.neg) →
((k : ℤ) → (a : Lean.Grind.Linarith.Expr) → motive (Lean.Grind.Linarith.Expr.intMul k a)) →
(Unit → mo... | null | false |
List.sbtw_four | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {p₁ p₂ p₃ p₄ : P},
List.Sbtw R [p₁, p₂, p₃, p₄] ↔ Sbtw R p₁ p₂ p₃ ∧ Sbtw R p₁ p₂ p₄ ∧ Sbtw R p₁ p₃ p₄ ∧ Sbtw R p₂ p₃ p₄ | null | true |
Lean.Doc.instBEqMathMode.beq | Lean.DocString.Types | Lean.Doc.MathMode → Lean.Doc.MathMode → Bool | null | true |
FirstOrder.Language.Hom.id._proof_1 | Mathlib.ModelTheory.Basic | ∀ (L : FirstOrder.Language) (M : Type u_3) [inst : L.Structure M] {n : ℕ} (f : L.Functions n) (x : Fin n → M),
FirstOrder.Language.Structure.funMap f x = FirstOrder.Language.Structure.funMap f ((fun m => m) ∘ x) | null | false |
Std.ExtDTreeMap.Const.get_union_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.ExtDTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] {k : α} (not_mem : k ∉ t₁) {h' : k ∈ t₁.union t₂},
Std.ExtDTreeMap.Const.get (t₁.union t₂) k h' = Std.ExtDTreeMap.Const.get t₂ k ⋯ | null | true |
UniformSpace.Completion.induction_on | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α] {p : UniformSpace.Completion α → Prop} (a : UniformSpace.Completion α),
IsClosed {a | p a} → (∀ (a : α), p ↑a) → p a | null | true |
MeasureTheory.Measure.addHaar_singleton_add_smul_div_singleton_add_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
r ≠ 0 → ∀ (x y : E) (s t : Set E), μ ({x} + r • s) / μ ({y} + r • t) = μ s / μ t | null | true |
Lean.Elab.DerivingClassView.cls | Lean.Elab.Deriving.Basic | Lean.Elab.DerivingClassView → Lean.Term | null | true |
Polynomial.Bivariate.swap_swap_apply | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (p : Polynomial (Polynomial R)),
Polynomial.Bivariate.swap (Polynomial.Bivariate.swap p) = p | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.toFunctorToCategoricalPullback_obj_obj_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] (S : Cat... | null | true |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.ciSup_subtype.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {ι : Sort u_1} {p : ι → Prop} (motive : Subtype p → Prop) (h : Subtype p),
(∀ (i : ι) (h : p i), motive ⟨i, h⟩) → motive h | null | false |
Matrix.Hessenberg.Similarity.isUpperHessenberg | Mathlib.LinearAlgebra.Matrix.Hessenberg.Similarity | ∀ {m : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : Fintype m] [inst_2 : LinearOrder m] [inst_3 : SuccOrder m]
{A : Matrix m m R} (self : Matrix.Hessenberg.Similarity A), self.H.IsUpperHessenberg | null | true |
CategoryTheory.AddGrp.instAddMonObj._proof_7 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {H : CategoryTheory.AddGrp C}
[inst_3 : CategoryTheory.IsCommAddMonObj H.X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStr... | null | false |
Subalgebra.mk.congr_simp | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(toSubsemiring toSubsemiring_1 : Subsemiring A) (e_toSubsemiring : toSubsemiring = toSubsemiring_1)
(algebraMap_mem' : ∀ (r : R), (algebraMap R A) r ∈ toSubsemiring.carrier),
{ toSubsemiring := toSubsemiring, algebraM... | null | true |
map_nonpos | Mathlib.Algebra.Order.Hom.Monoid | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Preorder α] [inst_2 : Zero α]
[inst_3 : Preorder β] [inst_4 : Zero β] [OrderHomClass F α β] [ZeroHomClass F α β] (f : F) {a : α}, a ≤ 0 → f a ≤ 0 | null | true |
ModuleCat.Hom._mkInternal.sizeOf_spec | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R} [inst_1 : SizeOf R] (hom' : ↑M →ₗ[R] ↑N),
sizeOf { hom' := hom' } = 1 + sizeOf hom' | null | false |
Std.DTreeMap.maxKey?_eq_none_iff | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.maxKey? = none ↔ t.isEmpty = true | null | true |
Lean.Language.ProcessingContext._sizeOf_inst | Lean.Language.Basic | SizeOf Lean.Language.ProcessingContext | null | false |
TensorProduct.AlgebraTensorModule.rightComm | Mathlib.LinearAlgebra.TensorProduct.Tower | (R : Type uR) →
(S : Type uS) →
(B : Type uB) →
(M : Type uM) →
(P : Type uP) →
(Q : Type uQ) →
[inst : CommSemiring R] →
[inst_1 : Semiring B] →
[inst_2 : Algebra R B] →
[inst_3 : AddCommMonoid M] →
[inst_4 : ... | A tensor product analogue of `mul_right_comm`.
Suppose we have a diagram of algebras `R → B ← S`,
and a `B`-module `M`, `S`-module `P`, `R`-module `Q`, then
```
(M ⊗ˢ P) ⎛ M ⎞ ⊗ˢ P
⊗ᴿ ≅ᴮ ⎜ ⊗ᴿ⎟
Q ⎝ Q ⎠
```
| true |
AddCon.mapGen.eq_1 | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {c : AddCon M} (f : M → N),
AddCon.mapGen f = addConGen (Relation.Map (⇑c) f f) | null | true |
RingEquiv.op_apply_apply | Mathlib.Algebra.Ring.Equiv | ∀ {α : Type u_7} {β : Type u_8} [inst : Add α] [inst_1 : Mul α] [inst_2 : Add β] [inst_3 : Mul β] (f : α ≃+* β)
(a : αᵐᵒᵖ), (RingEquiv.op f) a = MulOpposite.op (f (MulOpposite.unop a)) | null | true |
ApproximatesLinearOn.toPartialEquiv._proof_3 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {E : Type u_1} [NormedAddCommGroup E], Nonempty E | null | false |
ZMod.cast_descFactorial | Mathlib.Data.ZMod.Factorial | ∀ {n p : ℕ}, n ≤ p → ↑((p - 1).descFactorial n) = (-1) ^ n * ↑n.factorial | null | true |
Configuration.HasLines.hasPoints._proof_1 | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} [inst : Membership P L] [Configuration.HasLines P L] [inst_2 : Fintype P]
[inst_3 : Fintype L], Fintype.card P = Fintype.card L → ∀ (l₁ l₂ : L), l₁ ≠ l₂ → ∃ p ∈ l₁, p ∈ l₂ | null | false |
Lean.Parser.Command.GrindCnstr.notStrictValue | Lean.Meta.Tactic.Grind.Parser | Lean.Parser.Parser | null | true |
Std.TreeMap.getElem?_diff_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∉ t₂ → (t₁ \ t₂)[k]? = t₁[k]? | null | true |
LinearMap.rank_zero | Mathlib.LinearAlgebra.Dimension.LinearMap | ∀ {K : Type u} {V : Type v} {V' : Type v'} [inst : Semiring K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
[inst_3 : AddCommMonoid V'] [inst_4 : Module K V'] [Nontrivial K], LinearMap.rank 0 = 0 | null | true |
CategoryTheory.SpectralSequence.instCategory._proof_7 | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {κ : Type u_3}
{c : ℤ → ComplexShape κ} {r₀ : ℤ} {X Y Z : CategoryTheory.SpectralSequence C c r₀} (f : X.Hom Y) (g : Y.Hom Z)
(r r' : ℤ) (hrr' : κ) (pq : r + 1 = r') (hr : r₀ ≤ r),
CategoryTheory.CategoryStruct.comp... | null | false |
Lean.LLVM.constIntSizeT | Lean.Compiler.IR.LLVMBindings | (ctx : Lean.LLVM.Context) → UInt64 → optParam Bool false → BaseIO (Lean.LLVM.Value ctx) | null | true |
Std.DTreeMap.Raw.getKey?_eq_some_getKey! | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t.WF → ∀ {a : α}, a ∈ t → t.getKey? a = some (t.getKey! a) | null | true |
CompHaus.epi_iff_surjective | Mathlib.Topology.Category.CompHaus.Basic | ∀ {X Y : CompHaus} (f : X ⟶ Y), CategoryTheory.Epi f ↔ Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
Finset.mulSpan.eq_1 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : DecidableEq α] [inst_2 : Fintype α] (s : Finset α),
s.mulSpan = Finset.image (fun ε => ∏ a ∈ s, a ^ ε a) (Fintype.piFinset fun _a => {-1, 0, 1}) | null | true |
Std.DTreeMap.Const.minKey?_alter_eq_self | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k : α}
{f : Option β → Option β},
(Std.DTreeMap.Const.alter t k f).minKey? = some k ↔
(f (Std.DTreeMap.Const.get? t k)).isSome = true ∧ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
CategoryTheory.Limits.CatCospanTransform.whiskerleft_id | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | true |
Std.IterM.DefaultConsumers.forIn'.wf._unary._proof_6 | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {m : Type u_1 → Type u_3} {α β : Type u_1} [inst : Std.Iterator α m β] (γ : Type u_2)
(PlausibleForInStep : β → γ → ForInStep γ → Prop) (wf : Std.IteratorLoop.WellFounded α m PlausibleForInStep)
(P : β → Prop) (it : Std.IterM m β) (init : γ) (hP : ∀ (b : β), it.IsPlausibleIndirectOutput b → P b)
(it' : Std.Iter... | null | false |
_private.Init.Data.Array.Find.0.Array.finIdxOf?.eq_1 | Init.Data.Array.Find | ∀ {α : Type u} [inst : BEq α] (xs : Array α) (v : α), xs.finIdxOf? v = xs.idxOfAux v 0 | null | true |
ValuationSubring.unitGroupMulEquiv._proof_4 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K),
Function.RightInverse (fun x => ⟨(Units.map ↑A.subtype) x, ⋯⟩) fun x =>
{ val := ⟨↑↑x, ⋯⟩, inv := ⟨↑↑x⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ } | null | false |
Set.prod_eq | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} (s : Set α) (t : Set β), s ×ˢ t = Prod.fst ⁻¹' s ∩ Prod.snd ⁻¹' t | null | true |
_private.Lean.Elab.Tactic.Split.0.Lean.Elab.Tactic.evalSplit.match_3 | Lean.Elab.Tactic.Split | (motive : Option (List Lean.MVarId) → Sort u_1) →
(__x : Option (List Lean.MVarId)) →
((mvarIds : List Lean.MVarId) → motive (some mvarIds)) → ((x : Option (List Lean.MVarId)) → motive x) → motive __x | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.Internal.optionPelim'.match_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {α : Type u_1} →
{β : Sort u_3} →
(motive : (t : Option α) → (t = none → β) → ((val : α) → t = some val → β) → Sort u_2) →
(t : Option α) →
(n : t = none → β) →
(s : (val : α) → t = some val → β) →
((a : α) → (n : some a = none → β) → (s : (val : α) → some a = some val → β) → m... | null | false |
_private.Mathlib.Order.Notation.0.Top.ext.match_1 | Mathlib.Order.Notation | ∀ {α : Type u_1} (motive : Top α → Prop) (h : Top α), (∀ (top : α), motive { top := top }) → motive h | null | false |
instMonadEIO._aux_13 | Init.System.IO | {ε α β : Type} → EIO ε α → (α → EIO ε β) → EIO ε β | null | false |
isPiSystem_image_Iio | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set α), IsPiSystem (Set.Iio '' s) | null | true |
OrderAddMonoidIso.refl.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ (α : Type u_2) [inst : Preorder α] [inst_1 : Add α],
OrderAddMonoidIso.refl α = { toAddEquiv := AddEquiv.refl α, map_le_map_iff' := ⋯ } | null | true |
MeasureTheory.Measure.add_conv | Mathlib.MeasureTheory.Group.Convolution | ∀ {M : Type u_1} [inst : AddMonoid M] [inst_1 : MeasurableSpace M] [MeasurableAdd₂ M] (μ ν ρ : MeasureTheory.Measure M)
[MeasureTheory.SFinite μ] [MeasureTheory.SFinite ν] [MeasureTheory.SFinite ρ], (μ + ν).conv ρ = μ.conv ρ + ν.conv ρ | null | true |
QuadraticAlgebra.linearEquivTuple_apply | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R] (z : QuadraticAlgebra R a b),
(QuadraticAlgebra.linearEquivTuple a b) z = ![z.re, z.im] | null | true |
Lean.Elab.ErrorNameInfo.errorName | Lean.Elab.InfoTree.Types | Lean.Elab.ErrorNameInfo → Lean.Name | null | true |
DistribMulAction.toModuleEnd.congr_simp | Mathlib.LinearAlgebra.Projectivization.Action | ∀ (R : Type u_1) {S : Type u_3} (M : Type u_4) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Monoid S] [inst_4 : DistribMulAction S M] [inst_5 : SMulCommClass S R M],
DistribMulAction.toModuleEnd R M = DistribMulAction.toModuleEnd R M | null | true |
Lean.Grind.instOrderedRingNat | Init.GrindInstances.Ring.Nat | Lean.Grind.OrderedRing ℕ | null | true |
Std.Iter.toList.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α β : Type w} [inst : Std.Iterator α Id β] (it : Std.Iter β), it.toList = it.toIterM.toList.run | null | true |
PFunctor.Approx.Agree.casesOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}}
{motive :
{n : ℕ} →
(a : PFunctor.Approx.CofixA F n) → (a_1 : PFunctor.Approx.CofixA F (n + 1)) → PFunctor.Approx.Agree a a_1 → Prop}
{n : ℕ} {a : PFunctor.Approx.CofixA F n} {a_1 : PFunctor.Approx.CofixA F (n + 1)} (t : PFunctor.Approx.Agree a a_1),
(∀ (x : PFunctor.Approx.Cof... | null | false |
Std.TreeSet.Raw.isEmpty_eq_false_iff_exists_contains_eq_true | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → (t.isEmpty = false ↔ ∃ a, t.contains a = true) | null | true |
MeasureTheory.condExpIndL1.congr_simp | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1 | ∀ {α : Type u_1} {G : Type u_4} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m m0 : MeasurableSpace α}
(hm : m ≤ m0) (μ : MeasureTheory.Measure α) (s s_1 : Set α),
s = s_1 →
∀ [inst_2 : MeasureTheory.SigmaFinite (μ.trim hm)] (x x_1 : G),
x = x_1 → MeasureTheory.condExpIndL1 hm μ s x = Measure... | null | true |
CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_inv_naturality_assoc | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasInjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X)
(J : ... | null | true |
IsNatCastApplyEqSMul.recOn | Mathlib.Algebra.Group.IsApply | {F : Type u_1} →
{α : Type u_2} →
[inst : FunLike F α α] →
[inst_1 : NatCast F] →
[inst_2 : SMul ℕ α] →
{motive : IsNatCastApplyEqSMul F α → Sort u} →
(t : IsNatCastApplyEqSMul F α) →
((natCast_apply_eq_smul : ∀ (n : ℕ) (x : α), ↑n x = n • x) → motive ⋯) → motive ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.