name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CommRingCat.coyoneda._proof_4 | Mathlib.Algebra.Category.Ring.Adjunctions | ∀ (X : Type u_1ᵒᵖ),
{
app := fun R =>
CommRingCat.ofHom
(RingHom.pi fun x =>
Pi.evalRingHom (fun a => ↑R)
((CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X).unop) x)),
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id
{ obj :... | null | false |
CompleteLatticeHom.OrderIso.toCompleteLatticeHom._proof_1 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β) (s : Set α),
f (sInf s) = sInf (⇑f '' s) | null | false |
Mathlib.Meta.NormNum.isInt_le_true | Mathlib.Tactic.NormNum.Ineq | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] {a b : α} {a' b' : ℤ},
Mathlib.Meta.NormNum.IsInt a a' → Mathlib.Meta.NormNum.IsInt b b' → decide (a' ≤ b') = true → a ≤ b | null | true |
_private.Mathlib.Basic.Real.ConjExponents.0.Real.HolderConjugate.div_conj_eq_sub_one._simp_1_2 | Mathlib.Basic.Real.ConjExponents | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Functor.0.AlgebraicGeometry.ProjectiveSpectrum.comap._simp_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Functor | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (s : Set Y), IsClosed s → IsClosed (f ⁻¹' s) | null | false |
Filter.Germ.instSemiring._proof_4 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {R : Type u_2} [inst : Semiring R] (x : l.Germ R), x ^ 0 = 1 | null | false |
LinearEquiv.rTensor_mul | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (f g : N ≃ₗ[R] N),
LinearEquiv.rTensor M (f * g) = LinearEquiv.rTensor M f * LinearEquiv.rTensor M g | null | true |
WittVector.wittNSMul._proof_1 | Mathlib.RingTheory.WittVector.Defs | NeZero (0 + 1) | null | false |
_private.Mathlib.RingTheory.Ideal.Pointwise.0.Ideal.instNormalSubtypeMemSubgroupStabilizerInertia._simp_1 | Mathlib.RingTheory.Ideal.Pointwise | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.Normal = ∀ (g : G), Subgroup.map (↑(MulAut.conj g)) H = H | null | false |
_private.Aesop.Forward.Match.0.Aesop.forwardRuleMatchesToRules?.match_1 | Aesop.Forward.Match | (motive : Option (Array Aesop.ForwardRuleMatch) → Sort u_1) →
(x : Option (Array Aesop.ForwardRuleMatch)) →
((ms : Array Aesop.ForwardRuleMatch) → motive (some ms)) →
((x : Option (Array Aesop.ForwardRuleMatch)) → motive x) → motive x | null | false |
LinearMap.BilinForm.IsAlt.sub | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R₁ : Type u_3} {M₁ : Type u_4} [inst : CommRing R₁] [inst_1 : AddCommGroup M₁] [inst_2 : Module R₁ M₁]
{B₁ B₂ : LinearMap.BilinForm R₁ M₁}, B₁.IsAlt → B₂.IsAlt → (B₁ - B₂).IsAlt | null | true |
Set.univ_sub_univ | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α], Set.univ - Set.univ = Set.univ | null | true |
HasGradientAt.hasDerivAt | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {g : 𝕜 → 𝕜} {g' u : 𝕜}, HasGradientAt g g' u → HasDerivAt g ((starRingEnd 𝕜) g') u | null | true |
OmegaCompletePartialOrder.ContinuousHom.ωSup_def | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c : OmegaCompletePartialOrder.Chain (α →𝒄 β)),
OmegaCompletePartialOrder.ωSup c = OmegaCompletePartialOrder.ContinuousHom.ωSup c | null | true |
HasDerivWithinAt.hasDerivAt | 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 → s ∈ nhds x → HasDerivAt f f' x | null | true |
Std.TransCmp | Init.Data.Order.Ord | {α : Type u} → (α → α → Ordering) → Prop | A typeclass for functions `α → α → Ordering` which are transitive. | true |
Int.neg_log_inv_eq_clog | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
(b : ℕ) (r : R), -Int.log b r⁻¹ = Int.clog b r | null | true |
Lean.Lsp.SignatureHelp.recOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SignatureHelp → Sort u} →
(t : Lean.Lsp.SignatureHelp) →
((signatures : Array Lean.Lsp.SignatureInformation) →
(activeSignature? activeParameter? : Option ℕ) →
motive
{ signatures := signatures, activeSignature? := activeSignature?, activeParameter? := activeParame... | null | false |
CategoryTheory.Presheaf.IsLocallySurjective.recOn | Mathlib.CategoryTheory.Sites.LocallySurjective | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{FA : A → A → Type u_1} →
{CA : A → Type w'} →
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (C... | null | false |
AlgebraicTopology.DoldKan.Q_idem | Mathlib.AlgebraicTopology.DoldKan.Projections | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} (q : ℕ),
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.Q q) (AlgebraicTopology.DoldKan.Q q) =
AlgebraicTopology.DoldKan.Q q | null | true |
_private.Mathlib.RingTheory.Artinian.Module.0.isArtinian_of_fg_of_artinian'.match_1 | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ n f, Function.Surjective ⇑f) → Prop) (x : ∃ n f, Function.Surjective ⇑f),
(∀ (w : ℕ) (w_1 : (Fin w → R) →ₗ[R] M) (h : Function.Surjective ⇑w_1), motive ⋯) → motive x | null | false |
finAddFlip_apply_mk_right | Mathlib.Logic.Equiv.Fin.Basic | ∀ {m n k : ℕ} (h₁ : m ≤ k) (h₂ : k < m + n), finAddFlip ⟨k, h₂⟩ = ⟨k - m, ⋯⟩ | null | true |
Rat.natFloor_natCast_div_natCast | Mathlib.Data.Rat.Floor | ∀ (n d : ℕ), ⌊↑n / ↑d⌋₊ = n / d | null | true |
asymptoticCone_empty | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V], asymptoticCone k ∅ = ∅ | null | true |
Int32.instRxiHasSize | Init.Data.Range.Polymorphic.SInt | Std.Rxi.HasSize Int32 | null | true |
CategoryTheory.normalOfIsPullbackFstOfNormal | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q R S : C} →
{f : P ⟶ Q} →
{g : P ⟶ R} →
{h : Q ⟶ S} →
{k : R ⟶ S} →
[CategoryTheory.NormalMono k] →
(comm : Ca... | The first leg of a pullback cone is a normal monomorphism if the left component is too.
See also `pullback.fstOfMono` for the basic monomorphism version, and
`normalOfIsPullbackSndOfNormal` for the flipped version.
| true |
CategoryTheory.WithInitial.equivComma_unitIso_inv_app_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(X : CategoryTheory.Functor (CategoryTheory.WithInitial C) D) (X_1 : CategoryTheory.WithInitial C),
(CategoryTheory.WithInitial.equivComma.unitIso.inv.app X).app X_1 =
(match X_1 with
| ... | null | true |
ModelWithCorners.isInteriorPoint_iff_of_mem_atlas | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : 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] {n : WithTop ℕ∞} [IsManifold I n M]
{... | A point `x` in a C¹ manifold is an interior point if and only if it gets mapped to the interior
of the model space by any given chart - in other words, the notion of interior points does not
depend on any choice of charts. | true |
aemeasurable_lineDeriv_uncurry | Mathlib.Analysis.Calculus.LineDeriv.Measurable | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [LocallyCompactSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : MeasurableSpace E] [OpensMeasurableSpace E]
{F : Type u_3} [inst_6 : NormedAddCommGroup F] [inst_7 : NormedSpace 𝕜 F] [CompleteSpace F] {f : E → F}
[... | null | true |
InnerProductGeometry.inner_eq_mul_norm_of_angle_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
InnerProductGeometry.angle x y = 0 → inner ℝ x y = ‖x‖ * ‖y‖ | If the angle between two vectors is 0, the inner product equals the product of the norms. | true |
CategoryTheory.Functor.mapTriangle_obj | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
(T : CategoryTheory.Pretriangulated.Triangle C),
F... | null | true |
FiniteDimensional.exists_mul_eq_one | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ (F : Type u_1) {K : Type u_2} [inst : Field F] [inst_1 : Ring K] [IsDomain K] [inst_3 : Algebra F K]
[FiniteDimensional F K] {x : K}, x ≠ 0 → ∃ y, x * y = 1 | null | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.forget_preservesPullbackOfLeft | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Z) (g : Y ⟶ Z)
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f],
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g)
AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace | null | true |
Ctop.Realizer.nhds | Mathlib.Data.Analysis.Topology | {α : Type u_1} → [inst : TopologicalSpace α] → Ctop.Realizer α → (a : α) → (nhds a).Realizer | A realizer of the neighborhood of a point. | true |
dist_le_Ico_sum_dist | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] (f : ℕ → α) {m n : ℕ},
m ≤ n → dist (f m) (f n) ≤ ∑ i ∈ Finset.Ico m n, dist (f i) (f (i + 1)) | The triangle (polygon) inequality for sequences of points; `Finset.Ico` version. | true |
CategoryTheory.isCofiltered_of_semilatticeInf_nonempty | Mathlib.CategoryTheory.Filtered.Basic | ∀ (α : Type u) [inst : SemilatticeInf α] [Nonempty α], CategoryTheory.IsCofiltered α | null | true |
_private.Init.Data.List.Lex.0.List.lex_eq_decide_lex._simp_1_5 | Init.Data.List.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {a : α} {l₁ : List α} {b : α} {l₂ : List α},
List.Lex r (a :: l₁) (b :: l₂) = (r a b ∨ a = b ∧ List.Lex r l₁ l₂) | null | false |
perfectClosure.perfectRing | Mathlib.FieldTheory.PurelyInseparable.PerfectClosure | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (p : ℕ) [ExpChar E p]
[PerfectRing E p], PerfectRing (↥(perfectClosure F E)) p | If `E` is a perfect field of exponential characteristic `p`, then the (relative) perfect closure
`perfectClosure F E` is perfect. | true |
Nat.instDecidableIsPowerOfTwo | Init.Data.Nat.Power2.Bitwise | {n : ℕ} → Decidable n.isPowerOfTwo | null | true |
HomologicalComplex.instAdditiveHomologyFunctor | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (i : ι) [inst_2 : CategoryTheory.CategoryWithHomology C],
(HomologicalComplex.homologyFunctor C c i).Additive | null | true |
_private.Lean.Compiler.LCNF.SplitSCC.0.Lean.Compiler.LCNF.SplitScc.findSccCalls.goCode._sparseCasesOn_4 | Lean.Compiler.LCNF.SplitSCC | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) → motive_4 (Lean.Compiler.LCNF.Code.let decl k)) →
(Nat.hasNotBit 1 t.ctorIdx → motive_4 t) → ... | null | false |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_anticollision | Mathlib.NumberTheory.Rayleigh | ∀ {r s : ℝ}, r.HolderConjugate s → ¬∃ j k m, ↑k < ↑j / r ∧ (↑j + 1) / r ≤ ↑k + 1 ∧ ↑m ≤ ↑j / s ∧ (↑j + 1) / s < ↑m + 1 | Let `r > 1` and `1/r + 1/s = 1`. Suppose there is an integer `j` where `B_r` and `B'_s` both
jump over `j` (i.e. an anti-collision). Then this leads to a contradiction. | true |
LinearEquiv.le_one_add_finrank_fixedSubmodule_dilatransvection_mul | Mathlib.LinearAlgebra.Transvection.Generation | ∀ {K : Type u_1} [inst : DivisionRing K] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[Module.Finite K V] (e f : V ≃ₗ[K] V),
f ∈ LinearEquiv.dilatransvections K V →
Module.finrank K ↥(↑e).fixedSubmodule ≤ 1 + Module.finrank K ↥(↑(f * e)).fixedSubmodule | null | true |
SubMulAction.map_ofFixingSubgroupUnion._proof_6 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_2) {α : Type u_1} [inst : Group M] [inst_1 : MulAction M α] (s t : Set α) (m : M)
(hm : m ∈ fixingSubgroup M (s ∪ t)) (x : α) (hx : x ∈ SubMulAction.ofFixingSubgroup M (s ∪ t)),
⟨⟨↑(⟨m, hm⟩ • ⟨x, hx⟩), ⋯⟩, ⋯⟩ = ⟨⟨↑⟨m, hm⟩, ⋯⟩, ⋯⟩ • ⟨⟨↑⟨x, hx⟩, ⋯⟩, ⋯⟩ | null | false |
NonAssocRing.mk | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
[toNonUnitalNonAssocRing : NonUnitalNonAssocRing α] →
[toOne : One α] →
(∀ (a : α), 1 * a = a) →
(∀ (a : α), a * 1 = a) →
[toNatCast : NatCast α] →
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam →
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n +... | null | true |
Option.map_map₂_antidistrib | Mathlib.Data.Option.NAry | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → β → γ} {a : Option α} {b : Option β}
{α' : Type u_5} {β' : Type u_6} {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'},
(∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)) →
Option.map g (Option.map₂ f a b) = Option.map₂ f' (Option.ma... | null | true |
BoxIntegral.Box.face.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Additive | ∀ {n : ℕ} (I : BoxIntegral.Box (Fin (n + 1))) (i : Fin (n + 1)),
I.face i = { lower := I.lower ∘ i.succAbove, upper := I.upper ∘ i.succAbove, lower_lt_upper := ⋯ } | null | true |
Lean.Parser.ParserExtension.OLeanEntry.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserExtension.OLeanEntry → Sort u} →
(t : Lean.Parser.ParserExtension.OLeanEntry) →
((val : Lean.Parser.Token) → motive (Lean.Parser.ParserExtension.OLeanEntry.token val)) →
((val : Lean.SyntaxNodeKind) → motive (Lean.Parser.ParserExtension.OLeanEntry.kind val)) →
((catName d... | null | false |
_private.Mathlib.SetTheory.Lists.0.Lists'.ofList_subset._simp_1_1 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : α} {l m : List α}, (a :: l ⊆ m) = (a ∈ m ∧ l ⊆ m) | null | false |
WithIdealFilter.idealSet | Mathlib.RingTheory.IdealFilter.Topology | {A : Type u_1} → [inst : Ring A] → {F : IdealFilter A} → Ideal A → Set (WithIdealFilter F) | View an ideal of `A` as a subset of `WithIdealFilter F`. | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.ofList_eq_empty_iff._simp_1_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m = ∅) = (m.isEmpty = true) | null | false |
MaxTropical.instLinearOrder._proof_5 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (a b : MaxTropical R),
MaxTropical.trop (min (MaxTropical.untrop a) (MaxTropical.untrop b)) = if a ≤ b then a else b | null | false |
WeierstrassCurve.exists_isMinimal | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] (W : WeierstrassCurve K),
∃ C, WeierstrassCurve.IsMinimal R (C • W) | null | true |
ProfiniteAddGrp.instAddGroupCarrierToTopTotallyDisconnectedSpacePtProfiniteLimitConeCompForget₂ContinuousAddMonoidHomToProfiniteContinuousMap._aux_8 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | {J : Type u_1} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_1 u_2}) →
ℕ →
↑(Profinite.limitCone (F.comp (CategoryTheory.forget₂ ProfiniteAddGrp.{max u_2 u_1} Profinite))).pt.toTop →
↑(Profinite.limitCone (F.comp (CategoryTheory.forget₂ Pr... | null | false |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff_frequently._simp_1_4 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) | null | false |
TensorProduct.congr_refl_refl | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N],
TensorProduct.congr (LinearEquiv.refl R M) (LinearEquiv.refl R N) = LinearEquiv.refl R (TensorProduct R M N) | null | true |
SmoothBumpCovering.noConfusion | Mathlib.Geometry.Manifold.PartitionOfUnity | {P : Sort u} →
{ι : Type uι} →
{E : Type uE} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{H : Type uH} →
{inst_2 : TopologicalSpace H} →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
{inst_3 : TopologicalSpace ... | null | false |
ForIn.recOn | Init.Core | {m : Type u₁ → Type u₂} →
{ρ : Type u} →
{α : Type v} →
{motive : ForIn m ρ α → Sort u_1} →
(t : ForIn m ρ α) →
((forIn : {β : Type u₁} → ρ → β → (α → β → m (ForInStep β)) → m β) → motive { forIn := forIn }) → motive t | null | false |
DFinsupp.sigmaCurryLEquiv._proof_3 | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_3} [inst : DecidableEq ι] {α : ι → Type u_2} {M : (i : ι) → α i → Type u_1}
[inst_1 : (i : ι) → (j : α i) → AddCommMonoid (M i j)],
Function.LeftInverse DFinsupp.sigmaCurryEquiv.invFun DFinsupp.sigmaCurryEquiv.toFun | null | false |
IsCompact.bddAbove_image | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : TopologicalSpace β]
[ClosedIciTopology α] [Nonempty α] {f : β → α} {K : Set β}, IsCompact K → ContinuousOn f K → BddAbove (f '' K) | A continuous function is bounded above on a compact set. | true |
String.Pos.startPos_lt_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} (p : s.Pos), s.startPos < p ↔ p ≠ s.startPos | null | true |
StarSubalgebra.isClosedEmbedding_inclusion | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
{S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂), IsClosed ↑S₁ → Topology.IsClosedEmbedding ⇑(StarSubalgebra.inclusion h) | The `StarSubalgebra.inclusion` of a closed star subalgebra is a `IsClosedEmbedding`. | true |
Algebra.IsStandardSmoothOfRelativeDimension.baseChange | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ (n : ℕ) {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_1)
[inst_3 : CommRing T] [inst_4 : Algebra R T] [Algebra.IsStandardSmoothOfRelativeDimension n R S],
Algebra.IsStandardSmoothOfRelativeDimension n T (TensorProduct R T S) | null | true |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.Inv2.property._proof_1 | Std.Sat.AIG.RelabelNat | ∀ {α : Type} (decls : Array (Std.Sat.AIG.Decl α)) (idx upper : ℕ),
idx < upper → upper ≤ decls.size → ¬idx < decls.size → False | null | false |
MulRingNorm.mulRingNormEquivAbsoluteValue | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : Ring R] → [Nontrivial R] → MulRingNorm R ≃ AbsoluteValue R ℝ | The equivalence of `MulRingNorm R` and `AbsoluteValue R ℝ` when `R` is a nontrivial ring. | true |
Lean.JsonRpc.ResponseError.mk | Lean.Data.JsonRpc | {α : Type u} → Lean.JsonRpc.RequestID → Lean.JsonRpc.ErrorCode → String → Option α → Lean.JsonRpc.ResponseError α | null | true |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.Ordered.balance1.match_1_4 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} (a : RBTree.RBNode α) (x : α) (b : RBTree.RBNode α) (y : α)
(c : RBTree.RBNode α)
(motive :
RBTree.RBNode.Ordered cmp
(RBTree.RBNode.node RBTree.RBColor.red (RBTree.RBNode.node RBTree.RBColor.red a x b) y c) →
Prop)
(hl :
RBTree.RBNode.Ordered cmp
... | null | false |
TopologicalSpace.IsTopologicalBasis.open_eq_iUnion_of_closure_subset | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [RegularSpace X] {B : Set (Set X)},
TopologicalSpace.IsTopologicalBasis B → ∀ {U : Set X}, IsOpen U → U = ⋃ v ∈ B, ⋃ (_ : closure v ⊆ U), v | In a regular space with a topological basis `B`, any open set `U` can be written as the union
of the sets in `B` whose closures are contained in `U`. | true |
Subgroup.isComplement_iff_existsUnique | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {S T : Set G}, Subgroup.IsComplement S T ↔ ∀ (g : G), ∃! x, ↑x.1 * ↑x.2 = g | null | true |
_private.Mathlib.RingTheory.Polynomial.Quotient.0.Ideal.eq_zero_of_polynomial_mem_map_range._simp_1_1 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {a : R} [inst_1 : I.IsTwoSided], ((Ideal.Quotient.mk I) a = 0) = (a ∈ I) | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.isCutsatType | Lean.Meta.Tactic.Grind.Arith.Linear.StructId | Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | true |
Int.Internal.Linear.Poly.mul.eq_1 | Init.Data.Int.Linear | ∀ (p : Int.Internal.Linear.Poly) (k : ℤ), p.mul k = if (k == 0) = true then Int.Internal.Linear.Poly.num 0 else p.mul' k | null | true |
cast_inj._simp_1 | Mathlib.Logic.Function.Basic | ∀ {α β : Type u} (h : α = β) {x y : α}, (cast h x = cast h y) = (x = y) | null | false |
TensorProduct.tensorTensorTensorComm_trans_tensorTensorTensorComm | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} {P : Type u_6} {Q : Type u_7}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R Q] [inst_8 : Module R P],
TensorProduct.te... | null | true |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.mkAntiquotNode._sparseCasesOn_4 | Lean.Elab.MacroArgUtil | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
motive Lean.Name.anonymous →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | null | false |
Matroid.isBasis_iff_isBasis_closure_of_subset._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.isUnit_sqrt_iff_isStrictlyPositive._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst_1 : Ring A] [inst_5 : Algebra ℝ A], SMulCommClass ℝ A A | null | false |
CategoryTheory.StrictlyUnitaryPseudofunctorCore.map₂_whisker_right | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryPseudofunctorCore B C) {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
self.map₂ (CategoryTheory.Bicategory.whiskerRight η h) =
CategoryTheory.CategoryStruct.comp (s... | null | true |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.IsStoppingTime.measurableSpace_const._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Lean.Lsp.LeanFileProgressParams.noConfusionType | Lean.Data.Lsp.Extra | Sort u → Lean.Lsp.LeanFileProgressParams → Lean.Lsp.LeanFileProgressParams → Sort u | null | false |
Subsemiring.map_comap_eq | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (t : Subsemiring S),
Subsemiring.map f (Subsemiring.comap f t) = t ⊓ f.rangeS | null | true |
Homotopy.mkCoinductive | Mathlib.Algebra.Homology.Homotopy | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{P Q : CochainComplex V ℕ} →
(e : P ⟶ Q) →
(zero : P.X 1 ⟶ Q.X 0) →
e.f 0 = CategoryTheory.CategoryStruct.comp (P.d 0 1) zero →
(one : P.X 2 ⟶ Q.X 1) →
... | A constructor for a `Homotopy e 0`, for `e` a chain map between `ℕ`-indexed cochain complexes,
working by induction.
You need to provide the components of the homotopy in degrees 0 and 1,
show that these satisfy the homotopy condition,
and then give a construction of each component,
and the fact that it satisfies the ... | true |
WithLp.continuous_snd | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
Continuous WithLp.snd | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.SolverExtension.mk._flat_ctor | Lean.Meta.Tactic.Grind.Types | {σ : Type} →
ℕ →
IO σ →
(Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit) →
(Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) →
(Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) →
Lean.Meta.Grind.GoalM Bool →
Lean.Meta.Grind.Action →
... | null | false |
_private.Lean.Meta.MethodSpecs.0.Lean.getMethodSpecsInfo.match_6 | Lean.Meta.MethodSpecs | (motive : Option Lean.StructureInfo → Sort u_1) →
(x : Option Lean.StructureInfo) →
((structInfo : Lean.StructureInfo) → motive (some structInfo)) →
((x : Option Lean.StructureInfo) → motive x) → motive x | null | false |
MeasureTheory.MeasureSpace.toMeasurableSpace | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | {α : Type u_5} → [self : MeasureTheory.MeasureSpace α] → MeasurableSpace α | null | true |
AddGrpCat.addGroupObj._proof_11 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddGrpCat) (j : J),
autoParam (∀ (n : ℕ) (x : (F.comp (CategoryTheory.forget AddGrpCat)).obj j), (n + 1) • x = n • x + x)
AddMonoid.nsmul_succ._autoParam | null | false |
Projectivization.instMulActionProjGenLinGroupForall._proof_2 | Mathlib.LinearAlgebra.Projectivization.Action | ∀ {K : Type u_1} [inst : Field K] {ι : Type u_2} [inst_1 : Fintype ι] [inst_2 : DecidableEq ι] (u : Kˣ) (v : ι → K)
(hv : v ≠ 0), (Matrix.GeneralLinearGroup.scalar ι) u • Projectivization.mk K v hv = Projectivization.mk K v hv | null | false |
BddOrd.dualEquiv_inverse | Mathlib.Order.Category.BddOrd | BddOrd.dualEquiv.inverse = BddOrd.dual | null | true |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.«_aux_Mathlib_Algebra_MvPolynomial_SchwartzZippel___macroRules__private_Mathlib_Algebra_MvPolynomial_SchwartzZippel_0_term_^^__1» | Mathlib.Algebra.MvPolynomial.SchwartzZippel | Lean.Macro | null | false |
TopologicalSpace.CompactOpens.ctorIdx | Mathlib.Topology.Sets.Compacts | {α : Type u_4} → {inst : TopologicalSpace α} → TopologicalSpace.CompactOpens α → ℕ | null | false |
Real.HolderTriple.inv_sub_inv_eq_inv | Mathlib.Basic.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → r⁻¹ - q⁻¹ = p⁻¹ | null | true |
Std.Time.Minute.instDecidableLtOrdinal._aux_1 | Std.Time.Time.Unit.Minute | {x y : Std.Time.Minute.Ordinal} → Decidable (x < y) | null | false |
LatticeHom.withBotWithTop'._proof_1 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder β] (f : LatticeHom α β),
f.withTop'.withBot'.toInfHom.toFun ⊥ = f.withTop'.withBot'.toInfHom.toFun ⊥ | null | false |
Array.start_mkSlice_roc | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo hi : ℕ},
(Std.Roc.Sliceable.mkSlice xs (lo<...=hi)).start = min (lo + 1) (min (hi + 1) xs.size) | null | true |
SSet.prodStdSimplex.pairingCore.Type₁.mk.injEq | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} (x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N) (d : ℕ)
(hd : x.dim = d + 1) (index : Fin (d + 1)) (isIndex : SSet.prodStdSimplex.pairingCore.IsIndex x hd index.succ)
(x_1 : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N) (d_1 : ℕ) (hd_1 : x_1... | null | true |
Set.union_eq_compl_compl_inter_compl | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (s t : Set α), s ∪ t = (sᶜ ∩ tᶜ)ᶜ | null | true |
CategoryTheory.ComposableArrows.Precomp.obj.match_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | {n : ℕ} →
(motive : Fin (n + 1 + 1) → Sort u_1) →
(x : Fin (n + 1 + 1)) →
((isLt : 0 < n + 1 + 1) → motive ⟨0, isLt⟩) →
((i : ℕ) → (hi : i + 1 < n + 1 + 1) → motive ⟨i.succ, hi⟩) → motive x | null | false |
NonUnitalStarAlgHom.map_star' | 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] [inst_6 : Star B] (self : A →⋆ₙₐ[R] B) (a : A),
self.toFun (star a) = star (self.toFun a) | By definition, a non-unital ⋆-algebra homomorphism preserves the `star` operation. | true |
Finset.sdiff_empty | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α}, s \ ∅ = s | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.