name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcycles_f | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | true |
Algebra.TensorProduct.instAddCommMonoidWithOne | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoidWithOne A] →
[inst_2 : Module R A] →
[inst_3 : AddCommMonoidWithOne B] → [inst_4 : Module R B] → AddCommMonoidWithOne (TensorProduct R A B) | null | true |
Quotient.exists_rep | Init.Core | ∀ {α : Sort u} {s : Setoid α} (q : Quotient s), ∃ a, ⟦a⟧ = q | null | true |
CategoryTheory.Cat.FreeRefl.hom_induction | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {V : Type u_1} [inst : CategoryTheory.ReflQuiver V] {motive : {x y : CategoryTheory.Cat.FreeRefl V} → (x ⟶ y) → Prop},
(∀ (x : V), motive (CategoryTheory.Cat.FreeRefl.homMk (CategoryTheory.ReflQuiver.id x))) →
(∀ {x y z : V} (f : CategoryTheory.Cat.FreeRefl.mk x ⟶ CategoryTheory.Cat.FreeRefl.mk y) (g : y ⟶ z),
... | null | true |
DoubleQuot.quotQuotMk.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : CommRing R] (I J : Ideal R),
DoubleQuot.quotQuotMk I J = (Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk I) J)).comp (Ideal.Quotient.mk I) | null | true |
IsLocalization.instAlgebraLocalizationAtPrime | Mathlib.RingTheory.Localization.LocalizationLocalization | {R : Type u_1} →
[inst : CommSemiring R] →
(x : Ideal R) → [H : x.IsPrime] → [IsDomain R] → Algebra (Localization.AtPrime x) (Localization (nonZeroDivisors R)) | null | true |
_private.Init.Data.Rat.Lemmas.0.Rat.lt_iff_le_and_ne._simp_1_4 | Init.Data.Rat.Lemmas | ∀ {a b : ℤ}, (a < b) = (a ≤ b ∧ a ≠ b) | null | false |
_private.Lean.Elab.PreDefinition.Basic.0.Lean.Elab.letToHaveValue._sparseCasesOn_1 | Lean.Elab.PreDefinition.Basic | {motive : Lean.Elab.DefKind → Sort u} →
(t : Lean.Elab.DefKind) →
motive Lean.Elab.DefKind.theorem →
motive Lean.Elab.DefKind.example →
motive Lean.Elab.DefKind.opaque → (Nat.hasNotBit 28 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Internal.Impl.get | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} → [inst : Ord α] → [Std.LawfulEqOrd α] → (t : Std.DTreeMap.Internal.Impl α β) → (k : α) → k ∈ t → β k | Returns the value for the key `k`. | true |
Fin.castSucc_one | Init.Data.Fin.Lemmas | ∀ {n : ℕ}, Fin.castSucc 1 = 1 | null | true |
Subgroup.instUniqueOfSubsingleton | Mathlib.Algebra.Group.Subgroup.Lattice | {G : Type u_1} → [inst : Group G] → [Subsingleton G] → Unique (Subgroup G) | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm.0.IntervalIntegrable.ae_hasDerivAt_integral._proof_1_10 | Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℝ → E} {a b : ℝ},
∀ c ∈ Set.Icc a b, ∀ y ∈ Set.Ioo a b, ∀ a_1 ∈ Set.Ioc y c, f a_1 = (fun x => if x ∈ Set.Ioc a b then f x else 0) a_1 | null | false |
_private.Mathlib.Analysis.BoxIntegral.Partition.Split.0.BoxIntegral.Box.coe_splitUpper._simp_1_4 | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
instWeakEMetricSpaceEReal | Mathlib.Topology.EMetricSpace.Weak | WeakEMetricSpace EReal | `EReal` is a weak extended metric space with its usual distance function. | true |
CategoryTheory.bifunctorComp₂₃._proof_4 | Mathlib.CategoryTheory.Functor.Trifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_5} {C₂₃ : Type u_10}
[inst : CategoryTheory.Category.{u_7, u_8} C₁] [inst_1 : CategoryTheory.Category.{u_1, u_2} C₂]
[inst_2 : CategoryTheory.Category.{u_6, u_3} C₃] [inst_3 : CategoryTheory.Category.{u_4, u_5} C₄]
[inst_4 : CategoryTheory.Category.{u... | null | false |
List.Sublist.flatMap_right | Mathlib.Data.List.Flatten | ∀ {α : Type u_1} {β : Type u_2} (l : List α) {f g : α → List β},
(∀ a ∈ l, (f a).Sublist (g a)) → (List.flatMap f l).Sublist (List.flatMap g l) | null | true |
Insert.casesOn | Init.Core | {α : Type u} →
{γ : Type v} →
{motive : Insert α γ → Sort u_1} →
(t : Insert α γ) → ((insert : α → γ → γ) → motive { insert := insert }) → motive t | null | false |
Lean.mkAnnotation | Lean.Expr | Lean.Name → Lean.Expr → Lean.Expr | Annotate `e` with the given annotation name `kind`.
It uses metadata to store the annotation.
| true |
ContMDiffAdd.recOn | Mathlib.Geometry.Manifold.Algebra.Monoid | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{n : WithTop ℕ∞} →
... | null | false |
LieIdeal.coe_lcs_eq | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
(M : Type u_3) [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (k : ℕ) [LieModule R L M],
↑(I.lcs M k) = ↑(LieModule.lowerCentralSeries R (↥I) M k) | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Pred.0.String.Slice.Pos.revSkipWhile_prop_eq_self_iff_get._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String.Slice} {pos : s.Pos},
(pos.revSkipWhile p = pos) = ∀ (h : pos ≠ s.startPos), p ((pos.prev h).get ⋯) = false | null | false |
Float.Model.UnpackedFloat.isNaN | Init.Data.Float.Model.Unpacked.Operations.Status | Float.Model.UnpackedFloat → Bool | Returns `true` if the float is `NaN`.
| true |
Std.HashMap.Raw.getKey_union_of_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (mem : k ∈ m₂), (m₁ ∪ m₂).getKey k ⋯ = m₂.getKey k mem | null | true |
HomotopicalAlgebra.PrepathObject.trans_p₁ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P P' : HomotopicalAlgebra.PrepathObject A)
[inst_1 : CategoryTheory.Limits.HasPullback P.p₁ P'.p₀],
(P.trans P').p₁ = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd P.p₁ P'.p₀) P'.p₁ | null | true |
PresheafOfModules.instAddCommGroupHom._proof_11 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (a b : M₁ ⟶ M₂), a + b = b + a | null | false |
List.Perm.eq_of_pairwise | Init.Data.List.Perm | ∀ {α : Type u_1} {le : α → α → Prop} {l₁ l₂ : List α},
(∀ (a b : α), a ∈ l₁ → b ∈ l₂ → le a b → le b a → a = b) →
List.Pairwise le l₁ → List.Pairwise le l₂ → l₁.Perm l₂ → l₁ = l₂ | If two lists are sorted by an antisymmetric relation, and permutations of each other,
they must be equal.
| true |
NonemptyFinLinOrd.instConcreteCategoryOrderHomCarrier | Mathlib.Order.Category.NonemptyFinLinOrd | CategoryTheory.ConcreteCategory NonemptyFinLinOrd fun x1 x2 => ↑x1.toLinOrd →o ↑x2.toLinOrd | null | true |
MaxTropical.trop_mul_def | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : Add R] (x y : MaxTropical R),
x * y = MaxTropical.trop (MaxTropical.untrop x + MaxTropical.untrop y) | null | true |
_private.Init.Internal.Order.Lemmas.0.Lean.Order.Functor.monotone_map._simp_1_1 | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} {inst : Monad m} [self : LawfulMonad m] {α β : Type u} (f : α → β) (x : m α),
f <$> x = do
let a ← x
pure (f a) | null | false |
MeasureTheory.SimpleFunc.integral_eq_sum | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [CompleteSpace E] (f : MeasureTheory.SimpleFunc α E),
MeasureTheory.Integrable (⇑f) μ → ∫ (x : α), f x ∂μ = ∑ x ∈ f.range, μ.real (⇑f ⁻¹' {x}) • x | null | true |
IsCompactlyGenerated.BooleanGenerators.distribLattice_of_sSup_eq_top | Mathlib.Order.BooleanGenerators | {α : Type u_1} →
[inst : CompleteLattice α] →
{S : Set α} → [IsCompactlyGenerated α] → IsCompactlyGenerated.BooleanGenerators S → sSup S = ⊤ → DistribLattice α | **Alias** of `IsCompactlyGenerated.BooleanGenerators.distribLatticeOfSSupEqTop`.
---
A lattice generated by Boolean generators is a distributive lattice. | true |
Functor.Comp.instSeq | Mathlib.Control.Functor | {F : Type u → Type w} → {G : Type v → Type u} → [Applicative F] → [Applicative G] → Seq (Functor.Comp F G) | null | true |
FirstOrder.Language.Hom.id_comp | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N] (f : L.Hom M N),
(FirstOrder.Language.Hom.id L N).comp f = f | null | true |
Std.Http.Internal.ChunkedBuffer.noConfusion | Std.Http.Internal.ChunkedBuffer | {P : Sort u} →
{t t' : Std.Http.Internal.ChunkedBuffer} → t = t' → Std.Http.Internal.ChunkedBuffer.noConfusionType P t t' | null | false |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing.0.ModularForm.E₄CubeSubE₆SqForm_apply | Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing | ∀ (z : UpperHalfPlane), ModularForm.E₄CubeSubE₆SqForm✝ z = ModularForm.E₄ z ^ 3 - ModularForm.E₆ z ^ 2 | null | true |
instCompleteLinearOrderWithBot._proof_2 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] (a b : WithBot α), b ≤ SemilatticeSup.sup a b | null | false |
PosNum.ofNatSucc._unsafe_rec | Mathlib.Data.Num.Basic | ℕ → PosNum | null | false |
OpenPartialHomeomorph.extend_symm_preimage_inter_range_eventuallyEq | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} {s : Set M} {x : M},
s ⊆ f.source... | **Alias** of `OpenPartialHomeomorph.extend_symm_preimage_inter_range_eventuallyEqSet`. | true |
Lean.Compiler.LCNF.FixedParams.evalApp | Lean.Compiler.LCNF.FixedParams | Lean.Name →
Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.FixedParams.FixParamM Unit | null | true |
PartialEquiv.IsImage.eq_1 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (s : Set α) (t : Set β),
e.IsImage s t = ∀ ⦃x : α⦄, x ∈ e.source → (↑e x ∈ t ↔ x ∈ s) | null | true |
continuousMultilinearCurryLeftEquiv._proof_5 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (G : Type u_1) [inst : NormedAddCommGroup G], ContinuousAdd G | null | false |
_private.Mathlib.SetTheory.Cardinal.Cofinality.Club.0.IsClub.diag._proof_1_1 | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type u_1} [inst : LinearOrder α] {f : α → Set α},
∀ t ⊆ {a | ∀ b < a, a ∈ f b}, ∀ (b c : α), b < c → t ∩ Set.Ici c ⊆ f b | null | false |
ContinuousMap.coe_mabs | Mathlib.Topology.ContinuousMap.Lattice | ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : TopologicalSpace β] [inst_2 : Group β]
[inst_3 : IsTopologicalGroup β] [inst_4 : Lattice β] [inst_5 : TopologicalLattice β] (f : C(α, β)), ⇑|f|ₘ = |⇑f|ₘ | null | true |
IsLinearTopology.casesOn | Mathlib.Topology.Algebra.LinearTopology | {R : Type u_1} →
{M : Type u_3} →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace M] →
{motive : IsLinearTopology R M → Sort u} →
(t : IsLinearTopology R M) →
((hasBasis_submodule' : (nhds 0).HasBasi... | null | false |
HomologicalComplex.HomologySequence.mapSnakeInput._proof_4 | Mathlib.Algebra.Homology.HomologySequenceLemmas | ∀ {C : Type u_3} {ι : Type u_1} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} (j : ι), (HomologicalComplex.cyclesFunctor C c j).PreservesZeroMorphisms | null | false |
Batteries.RunningStats.count | Batteries.Data.RunningStats | Batteries.RunningStats → ℕ | Number of data points, | true |
Ideal.quotientEquiv_symm_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {S : Type v} [inst_1 : Ring S] (I : Ideal R) (J : Ideal S) [inst_2 : I.IsTwoSided]
[inst_3 : J.IsTwoSided] (f : R ≃+* S) (hIJ : J = Ideal.map (↑f) I) (x : S),
(I.quotientEquiv J f hIJ).symm ((Ideal.Quotient.mk J) x) = (Ideal.Quotient.mk I) (f.symm x) | null | true |
Lean.Parser.Tactic.rewriteSeq | Init.Tactics | Lean.ParserDescr | `rewrite [e]` applies identity `e` as a rewrite rule to the target of the main goal.
If `e` is preceded by left arrow (`←` or `<-`), the rewrite is applied in the reverse direction.
If `e` is a defined constant, then the equational theorems associated with `e` are used.
This provides a convenient way to unfold `e`.
- `... | true |
_private.Std.Time.Date.Unit.Day.0.Std.Time.Day.instLawfulEqOrdOrdinal._proof_1 | Std.Time.Date.Unit.Day | Std.LawfulEqOrd Std.Time.Day.Ordinal | null | false |
LinearMap.isometryOfOrthonormal._proof_1 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {E' : Type u_2} [inst_3 : SeminormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] (f : E →ₗ[𝕜] E')
{v : Module.Basis ι 𝕜 E}, Orthonormal 𝕜 ⇑v → Orthonormal 𝕜 (⇑f ∘ ⇑v) →... | null | false |
AddOpposite.instNonUnitalCommRing._proof_1 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalCommRing R] (a b : Rᵃᵒᵖ), a * b = b * a | null | false |
AddMonoidHom.ofMapMidpoint._proof_2 | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ (R : Type u_4) (R' : Type u_2) {E : Type u_3} {F : Type u_1} [inst : Ring R] [inst_1 : Invertible 2]
[inst_2 : AddCommGroup E] [inst_3 : Module R E] [inst_4 : Ring R'] [inst_5 : Invertible 2] [inst_6 : AddCommGroup F]
[inst_7 : Module R' F] (f : E → F),
(∀ (x y : E), f (midpoint R x y) = midpoint R' (f x) (f y)... | null | false |
_private.Init.Data.String.Termination.0.String.Slice.Pos.wellFounded_lt._simp_1_2 | Init.Data.String.Termination | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
Finmap.mem_replace | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a a' : α} {b : β a} {s : Finmap β},
a' ∈ Finmap.replace a b s ↔ a' ∈ s | null | true |
_private.Mathlib.Tactic.Linarith.Frontend.0.Mathlib.Tactic.Linarith.linarithUsedHyps.match_7 | Mathlib.Tactic.Linarith.Frontend | (motive : Lean.MVarId × Option Lean.Expr × Option Lean.Expr → Sort u_1) →
(x : Lean.MVarId × Option Lean.Expr × Option Lean.Expr) →
((g : Lean.MVarId) → (target_type new_var : Option Lean.Expr) → motive (g, target_type, new_var)) → motive x | null | false |
CategoryTheory.Functor.rightAdjointObjIsDefined_of_adjunction | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (Y : D), F.rightAdjointObjIsDefined Y | null | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mreplaceError_1 | Std.Tactic.Do.Syntax | Lean.Macro | null | false |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.mem_insert_self.match_1_1 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {v : α} {t : RBTree.RBNode α}
(motive : (∃ L R, t.toList = L ++ R ∧ (RBTree.RBNode.insert cmp t v).toList = L ++ v :: R) → Prop)
(x : ∃ L R, t.toList = L ++ R ∧ (RBTree.RBNode.insert cmp t v).toList = L ++ v :: R),
(∀ (w w_1 : List α) (left : t.toList = w ++ w_1) (h : (RB... | null | false |
CategoryTheory.GradedObject.mapBifunctorBifunctor₂₃Desc.congr_simp | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
TwoSidedIdeal.orderIsoIdeal._proof_4 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] (J : Ideal R), ∀ x ∈ ↑J, x ∈ ↑(TwoSidedIdeal.mk' ↑J ⋯ ⋯ ⋯ ⋯ ⋯) | null | false |
Lean.Grind.CommRing.Poly.mulConst | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | true |
Manifold.IsSubmersionAtOfComplement.prodMap | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_1} {E' : Type u_2} {E'' : Type u_3} {E''' : Type u_4} {F : Type u_5} {F' : Type u_6} {H : Type u_7}
{H' : Type u_8} {G : Type u_9} {G' : Type u_10} {E : Type u} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E']
[inst_4 :... | If `f: M → N` and `g: M' → N'` are submersions at `x` and `x'`, respectively,
then `f × g: M × M' → N × N'` is a submersion at `(x, x')`. | true |
AddMagmaCat.comp_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {M N T : AddMagmaCat} (f : M ⟶ N) (g : N ⟶ T) (x : ↑M),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) x =
(CategoryTheory.ConcreteCategory.hom g) ((CategoryTheory.ConcreteCategory.hom f) x) | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.toBitVec_min._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toBitVec ≤ b.toBitVec) | null | false |
HomogeneousIdeal.toIdeal_comap | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Maps | ∀ {A : Type u_1} {B : Type u_2} {σ : Type u_4} {τ : Type u_5} {ι : Type u_7} [inst : Semiring A] [inst_1 : Semiring B]
[inst_2 : SetLike σ A] [inst_3 : SetLike τ B] [inst_4 : AddSubmonoidClass σ A] [inst_5 : AddSubmonoidClass τ B]
[inst_6 : DecidableEq ι] [inst_7 : AddMonoid ι] {𝒜 : ι → σ} {ℬ : ι → τ} [inst_8 : Gr... | null | true |
Ring.ordMonoidWithZeroHom_ne_zero | Mathlib.RingTheory.OrderOfVanishing.Noetherian | ∀ {R : Type u_2} [inst : CommRing R] [IsNoetherianRing R] [Ring.KrullDimLE 1 R] [inst_3 : Nontrivial R] {a : R},
a ∈ nonZeroDivisors R → (Ring.ordMonoidWithZeroHom R) a ≠ 0 | Analogue of `ord_ne_top` for `ordMonoidWithZeroHom`.
| true |
Module.Relations.Solution.IsPresentation.postcomp_uniq | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution : relations.Solution M} (h : solution.IsPresentation) {N : Type v'}
[inst_3 : AddCommGroup N] [inst_4 : Module A N] {solution' : relations.Solution N} (h' : solution'.IsPresentation... | null | true |
Finsupp.mapRange.linearMap_apply | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} {R : Type u_5} {R₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid N] [inst_5 : Module R₂ N] {σ₁₂ : R →+* R₂}
(f : M →ₛₗ[σ₁₂] N) (g : α →₀ M), (Finsupp.mapRange.linearMap f) g = Finsupp.map... | null | true |
CategoryTheory.ObjectProperty.commShiftι | Mathlib.CategoryTheory.ObjectProperty.Shift | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(P : CategoryTheory.ObjectProperty C) →
{A : Type u_2} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] → [inst_3 : P.IsStableUnderShift A] → P.ι.CommShift A | null | true |
instBooleanAlgebraAsBoolAlg._proof_11 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (x y z : AsBoolAlg α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
Mathlib.Tactic.LinearCombination.smul_eq_const | Mathlib.Tactic.LinearCombination.Lemmas | ∀ {α : Type u_1} {K : Type u_2} {t s : K} [inst : SMul K α], t = s → ∀ (c : α), t • c = s • c | null | true |
Nat.size_bit | Mathlib.Data.Nat.Size | ∀ {b : Bool} {n : ℕ}, Nat.bit b n ≠ 0 → (Nat.bit b n).size = n.size.succ | null | true |
_private.Mathlib.Topology.Connected.Clopen.0.isPreconnected_iff_subset_of_disjoint_closed._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s t : Set α}, (¬s ⊆ t) = ∃ a ∈ s, a ∉ t | null | false |
WithTop.strictAnti_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : WithTop α → β},
StrictAnti f ↔ (StrictAnti fun a => f ↑a) ∧ ∀ (x : α), f ⊤ < f ↑x | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL._proof_9 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (l r l_1 r_1 : Std.DTreeMap.Internal.Impl α β),
(l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) + 0 ≤ 1 ∨
l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size) ≤ 3 * 0 ∧
0 ≤ 3 * (l.size + 1 + r.size + 1 + (l_1.size + 1 + r_1.size))) ∨
1 ≤ l.size + 1 + r.s... | null | false |
HomotopicalAlgebra.RightHomotopyRel.leftHomotopy | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
{X Y : C} →
{f g : X ⟶ Y} →
[HomotopicalAlgebra.IsFibrant Y] →
HomotopicalAlgebra.RightHomotopyRel f g →
(Q : HomotopicalAlgebra.Cylinder X) → [Q.IsGood] → Q... | When two morphisms `X ⟶ Y` with `Y` fibrant are related by a right homotopy,
this is a choice of a left homotopy relative to any good cylinder object for `X`. | true |
MvPowerSeries.finSuccEquiv_X_succ | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ {R : Type u_2} [inst : CommSemiring R] {n : ℕ} (j : Fin n),
(MvPowerSeries.finSuccEquiv R n) (MvPowerSeries.X j.succ) = PowerSeries.C (MvPowerSeries.X j) | null | true |
CategoryTheory.Limits.createsFiniteColimitsOfCreatesCoequalizersAndFiniteCoproducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[CategoryTheory.Limits.HasCoequalizers D] →
[CategoryTheory.Limits.HasFiniteCoproducts D] →
(G : CategoryTheory.Functor C D) →
[G.ReflectsIso... | If a functor creates coequalizers and finite coproducts, it creates finite colimits.
We additionally require the rather strong condition that the functor reflects isomorphisms. It is
unclear whether the statement remains true without this condition. There are various definitions of
"creating colimits" in the literatur... | true |
Finset.coe_wcovBy_coe._simp_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} {s t : Finset α}, (↑s ⩿ ↑t) = (s ⩿ t) | null | false |
PEquiv.single_apply_of_ne | Mathlib.Basic.PEquiv | ∀ {α : Type u} {β : Type v} [inst : DecidableEq α] [inst_1 : DecidableEq β] {a₁ a₂ : α},
a₁ ≠ a₂ → ∀ (b : β), (PEquiv.single a₁ b) a₂ = none | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Stream.mk._flat_ctor | Std.Http.Data.Body.Stream | Std.Mutex Std.Http.Body.Channel.State✝ → Std.Http.Body.Stream | null | false |
Lean.Elab.ConfigEval.EvalConfigItemView.mk.noConfusion | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {P : Sort u} →
{omitFields : Array (Lean.Ident × Lean.Name)} →
{handlers : Array Lean.Elab.ConfigEval.EvalConfigItemHandler} →
{omitFields' : Array (Lean.Ident × Lean.Name)} →
{handlers' : Array Lean.Elab.ConfigEval.EvalConfigItemHandler} →
{ omitFields := omitFields, handlers := handlers ... | null | false |
Std.Http.Protocol.H1.decideRedirect | Std.Http.Protocol.H1.Redirect | Std.Http.URI.Origin →
Std.Http.Request.Head →
Bool → Bool → Std.Http.Version → Std.Http.Status → Std.Http.Headers → Std.Http.Protocol.H1.RedirectOutcome | Decides whether to follow a redirect given the server's response-line status, version, and headers,
the pending request, and whether the request body is replayable.
Returns `.done` when:
* the status is not a 3xx redirection,
* the response is HTTP/1.0 and the status code is not 301 or 302 (the only
redirect codes d... | true |
Aesop.ForwardRule.mk._flat_ctor | Aesop.Rule.Forward | ℕ →
ℕ →
Array (Array Aesop.Slot) →
Array Aesop.PremiseIndex →
Option (Aesop.RulePattern × Aesop.PremiseIndex) →
Aesop.RuleName → Aesop.RuleTerm → Aesop.ForwardRulePriority → Aesop.ForwardRule | null | false |
QuaternionAlgebra.starAe._proof_4 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R],
Function.RightInverse (starAddEquiv.trans MulOpposite.opAddEquiv).invFun
(starAddEquiv.trans MulOpposite.opAddEquiv).toFun | null | false |
Std.ExtHashSet.erase_empty | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {a : α}, ∅.erase a = ∅ | null | true |
Submodule.smul_of_tower_mem | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u'} {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p : Submodule R M) {x : M} [inst_2 : SMul S R] [inst_3 : SMul S M] [IsScalarTower S R M] (r : S), x ∈ p → r • x ∈ p | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.Compacts.continuous_prod.match_1_5 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (V : Set α) (W : Set β)
(motive : (x : TopologicalSpace.Compacts α × TopologicalSpace.Compacts β) → x ∈ {K | ↑K ⊆ V} ×ˢ {K | ↑K ⊆ W} → Prop)
(x : TopologicalSpace.Compacts α × TopologicalSpace.Compacts β) (x_1 : x ∈ {K | ↑K ⊆ ... | null | false |
Nat.getD_toArray_rcc_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i fallback : ℕ}, n + 1 ≤ i + m → (m...=n).toArray.getD i fallback = fallback | null | true |
EisensteinSeries.tendsto_E_atImInfty | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {k : ℕ} (hk : autoParam (3 ≤ k) EisensteinSeries.tendsto_E_atImInfty._auto_1),
autoParam (Even k) EisensteinSeries.tendsto_E_atImInfty._auto_3 →
Filter.Tendsto (⇑(ModularForm.E hk)) UpperHalfPlane.atImInfty (nhds 1) | The normalised Eisenstein series `E k` tends to `1` at `i∞`. | true |
Lean.PrefixTreeNode.WellFormed.recOn | Lean.Data.PrefixTree | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2}
{motive : (a : Lean.PrefixTreeNode α β cmp) → Lean.PrefixTreeNode.WellFormed cmp a → Prop}
{a : Lean.PrefixTreeNode α β cmp} (t : Lean.PrefixTreeNode.WellFormed cmp a),
motive Lean.PrefixTreeNode.empty ⋯ →
(∀ {t : Lean.PrefixTreeNode α β cmp} {k : List ... | null | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.D_subset_differentiable_set._proof_1_7 | Mathlib.Analysis.Calculus.FDeriv.Measurable | (11 + 1).AtLeastTwo | null | false |
Set.ncard_eq_zero._auto_1 | Mathlib.Data.Set.Card | Lean.Syntax | null | false |
String.Slice.toList_revPositions | Init.Data.String.Lemmas.Iterate | ∀ {s : String.Slice}, s.revPositions.toList = String.Slice.Model.revPositionsFrom s.endPos | null | true |
IsRadical | Mathlib.RingTheory.Nilpotent.Defs | {R : Type u_1} → [Dvd R] → [Pow R ℕ] → R → Prop | An element `y` in a monoid is radical if for any element `x`, `y` divides `x` whenever it
divides a power of `x`. | true |
Lean.MonadHashMapCacheAdapter.noConfusion | Lean.Util.MonadCache | {P : Sort u} →
{α β : Type} →
{m : Type → Type} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Lean.MonadHashMapCacheAdapter α β m} →
{α' β' : Type} →
{m' : Type → Type} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
... | null | false |
CategoryTheory.Oplax.StrongTrans.Hom._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
(η θ : F ⟶ G) → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.Oplax.StrongTrans.Hom η θ) | null | false |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.exists_nat_large | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ (a' b' : ℝ) {ε : ℝ}, 0 < ε → ∃ N, 0 < N ∧ a' / ↑N * (b' + a' / ↑N) ≤ ε | Choose `N` sufficiently large such that a particular quantity is small. | true |
AlgebraicGeometry.IsImmersion.rec | Mathlib.AlgebraicGeometry.Morphisms.Immersion | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsImmersion f → Sort u_1} →
([toIsPreimmersion : AlgebraicGeometry.IsPreimmersion f] →
(isLocallyClosed_range : IsLocallyClosed (Set.range ⇑f)) → motive ⋯) →
(t : AlgebraicGeometry.IsImmersion f) → motive t | null | false |
SimpleGraph.Iso.mapNeighborSet._proof_2 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G ≃g G') (v : V) (w : ↑(G.neighborSet v)),
(fun w => ⟨f.symm ↑w, ⋯⟩) ((fun w => ⟨f ↑w, ⋯⟩) w) = w | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.