name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.injective_map_zero._proof_1_1 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {D : Set X} (C : Set X) [inst : Topology.RelCWComplex C D]
⦃x z : Topology.RelCWComplex.cell C 0⦄, ¬x = z → ¬⟨0, x⟩ = ⟨0, z⟩ | null | false |
Orientation.map_refl | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] (ι : Type u_4),
Orientation.map ι (LinearEquiv.refl R M) = Equiv.refl (Orientation R M ι) | null | true |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.tilted_tilted._simp_1_6 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.coprodMonad_η_app | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C) [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
(x : C), (CategoryTheory.coprodMonad X).η.app x = CategoryTheory.Limits.coprod.inr | null | true |
FirstOrder.Language.Substructure.CG.map | Mathlib.ModelTheory.FinitelyGenerated | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] {N : Type u_2} [inst_1 : L.Structure N]
(f : L.Hom M N) {s : L.Substructure M}, s.CG → (FirstOrder.Language.Substructure.map f s).CG | null | true |
Lean.Meta.Diagnostics.heuristicCounter._default | Lean.Meta.Basic | Lean.PersistentHashMap Lean.Name ℕ | null | false |
UInt64.pow._f | Init.Data.UInt.Basic | UInt64 → (n : ℕ) → Nat.below n → UInt64 | null | false |
NumberField.HeightOneSpectrum.isNonarchimedean_adicAbv | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ (K : Type u_1) [inst : Field K] {R : Type u_3} [inst_1 : CommRing R] [inst_2 : Algebra R K]
[inst_3 : IsDedekindDomain R] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
[inst_5 : Ring.HasFiniteQuotients R] [inst_6 : Infinite R],
IsNonarchimedean ⇑(NumberField.HeightOneSpectrum.adicAbv ... | The `v`-adic absolute value is nonarchimedean | true |
MulEquiv.toContinuousMulEquiv._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {G : Type u_1} {H : Type u_2} [inst : Mul G] [inst_1 : Mul H] (e : G ≃* H), Function.LeftInverse e.invFun e.toFun | null | false |
Mathlib.Meta.Multiset.ProveZeroOrConsResult.cons.injEq | Mathlib.Tactic.NormNum.BigOperators | ∀ {u : Lean.Level} {α : Q(Type u)} {s : Q(Multiset «$α»)} (a : Q(«$α»)) (s' : Q(Multiset «$α»))
(pf : Q(«$s» = «$a» ::ₘ «$s'»)) (a_1 : Q(«$α»)) (s'_1 : Q(Multiset «$α»)) (pf_1 : Q(«$s» = «$a_1» ::ₘ «$s'_1»)),
(Mathlib.Meta.Multiset.ProveZeroOrConsResult.cons a s' pf =
Mathlib.Meta.Multiset.ProveZeroOrConsResu... | null | true |
LocallyFiniteOrder.orderMonoidWithZeroHom._proof_3 | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ (G : Type u_1) [inst : LinearOrderedCommGroupWithZero G] [inst_1 : LocallyFiniteOrder Gˣ] (a b : G),
a ≤ b →
(↑((WithZero.map' ↑(LocallyFiniteOrder.orderMonoidHom Gˣ)).comp
↑OrderMonoidIso.withZeroUnits.symm.toMulEquiv)).toFun
a ≤
(↑((WithZero.map' ↑(LocallyFiniteOrder.orderMonoidHom... | null | false |
AlgEquiv.toUnder | Mathlib.Algebra.Category.Ring.Under.Basic | {R : CommRingCat} →
{A B : Type u} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra (↑R) A] → [inst_3 : Algebra (↑R) B] → (A ≃ₐ[↑R] B) → (R.mkUnder A ≅ R.mkUnder B) | Make an isomorphism in `Under R` from an algebra isomorphism. | true |
Int8.right_eq_add | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, b = a + b ↔ a = 0 | null | true |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.getOtherDeclMonoType.match_1 | Lean.Compiler.LCNF.MonoTypes | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((type : Lean.Expr) → motive (some type)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
String.Slice.isEmpty_dropWhile | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.ForwardPattern pat] {s : String.Slice},
(s.dropWhile pat).isEmpty = s.all pat | null | true |
CategoryTheory.TwoSquare.structuredArrowDownwardsComp._proof_2 | Mathlib.CategoryTheory.GuitartExact.VerticalComposition | ∀ {C₁ : Type u_10} {C₂ : Type u_12} {C₃ : Type u_8} {D₁ : Type u_6} {D₂ : Type u_4} {D₃ : Type u_2}
[inst : CategoryTheory.Category.{u_9, u_10} C₁] [inst_1 : CategoryTheory.Category.{u_11, u_12} C₂]
[inst_2 : CategoryTheory.Category.{u_7, u_8} C₃] [inst_3 : CategoryTheory.Category.{u_5, u_6} D₁]
[inst_4 : Categor... | null | false |
FiniteIndexNormalSubgroup.instLattice._proof_1 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : Group G] (a b : FiniteIndexNormalSubgroup G), SemilatticeInf.inf a b ≤ a | null | false |
Set.mem_of_mem_insert_of_ne | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a b : α}, b ∈ insert a s → b ≠ a → b ∈ s | null | true |
Nat.ceilRoot_zero_right | Mathlib.Data.Nat.Factorization.Root | ∀ (n : ℕ), n.ceilRoot 0 = 0 | null | true |
Submodule.comap_smul | Mathlib.Algebra.Module.Submodule.Map | ∀ {K : Type u_7} {V : Type u_8} {V₂ : Type u_9} [inst : Semifield K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
[inst_3 : AddCommMonoid V₂] [inst_4 : Module K V₂] (f : V →ₗ[K] V₂) (p : Submodule K V₂) (a : K),
a ≠ 0 → Submodule.comap (a • f) p = Submodule.comap f p | null | true |
CategoryTheory.GrothendieckTopology.OneHypercover.IsPreservedBy.recOn | Mathlib.CategoryTheory.Sites.Continuous | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →
{E : J.OneHypercover X} →
{F : CategoryTheory.Functor C D} →
{K : ... | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceOfIntLE._regBuiltin.Int32.reduceOfIntLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.371 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
Std.HashMap.Equiv.getElem?_eq | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, m₁.Equiv m₂ → m₁[k]? = m₂[k]? | null | true |
Std.DTreeMap.Internal.Impl.Tree.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{size : ℕ} →
(impl : Std.DTreeMap.Internal.Impl α β) →
impl.Balanced → impl.size = size → Std.DTreeMap.Internal.Impl.Tree α β size | null | false |
Lean.Server.GoToKind.rec | Lean.Server.GoTo | {motive : Lean.Server.GoToKind → Sort u} →
motive Lean.Server.GoToKind.declaration →
motive Lean.Server.GoToKind.definition → motive Lean.Server.GoToKind.type → (t : Lean.Server.GoToKind) → motive t | null | false |
Lean.Grind.CommRing.d_normEq0_cert | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Bool | null | true |
CategoryTheory.CardinalFilteredPoset.coconeWithTop | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | {κ : Cardinal.{u}} →
[inst : Fact κ.IsRegular] →
(J : CategoryTheory.CardinalDirectedPoset κ) →
(κ' : Cardinal.{u}) →
[inst_1 : Fact κ'.IsRegular] →
CategoryTheory.Limits.Cocone
(CategoryTheory.CardinalDirectedPoset.functorOfPredicateSet (J.PropSetWithTop κ')) | **Alias** of `CategoryTheory.CardinalDirectedPoset.coconeWithTop`.
---
If `J : CardinalDirectedPoset κ` and `κ'` is any regular cardinal,
this is a colimit cocone which exhibits `J.withTop` as the `κ'`-filtered
colimit of its subsets that are of cardinality `< κ'` and contain `⊤`. | true |
CategoryTheory.ComposableArrows.homMk₂._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | 0 < 2 + 1 | null | false |
Std.Http.Protocol.H1.Machine.halted | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Machine dir → Bool | Returns `true` if both reader and writer are closed and no output remains.
| true |
_private.Init.Data.List.Find.0.List.lt_findIdx_iff.match_1_1 | Init.Data.List.Find | ∀ {α : Type u_1} (xs : List α) (p : α → Bool) (i : ℕ)
(motive : (∃ (h : i < xs.length), ∀ (j : ℕ) (hj : j ≤ i), p xs[j] = false) → Prop)
(x : ∃ (h : i < xs.length), ∀ (j : ℕ) (hj : j ≤ i), p xs[j] = false),
(∀ (h : i < xs.length) (w : ∀ (j : ℕ) (hj : j ≤ i), p xs[j] = false), motive ⋯) → motive x | null | false |
MvPFunctor.M.pathDestLeft | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} →
(P : MvPFunctor.{u} (n + 1)) →
{α : TypeVec.{u_1} n} →
{x : P.last.M} →
{a : P.A} →
{f : P.last.B a → P.last.M} → x.dest = ⟨a, f⟩ → TypeVec.Arrow (MvPFunctor.M.Path P x) α → (P.drop.B a).Arrow α | Implementation of destructor for M-type of `P` | true |
Lean.Meta.Grind.Arith.CommRing.Ring.denote._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Grind.Arith.CommRing.RingExpr | null | false |
ProbabilityTheory.iSup_bayesRisk_le_minimaxRisk | Mathlib.Probability.Decision.Risk.Basic | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_4} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} (ℓ : Θ → 𝓨 → ENNReal) (P : ProbabilityTheory.Kernel Θ 𝓧),
⨆ π, ⨆ (_ : MeasureTheory.IsProbabilityMeasure π), ProbabilityTheory.bayesRisk ℓ P π ≤
ProbabilityTheory.minimaxRisk ℓ P | The maximal Bayes risk is less than or equal to the minimax risk. | true |
Std.Internal.List.Const.getValueD_map | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [EquivBEq α] {fallback : γ} {f : α → β → γ}
{l : List ((_ : α) × β)},
Std.Internal.List.DistinctKeys l →
∀ {k : α},
Std.Internal.List.getValueD k (List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) l) fallback =
(Option.pmap (fun v h => f (Std.Intern... | null | true |
Prefunctor.star_fst | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V) (u : U) (a : Quiver.Star u),
(φ.star u a).fst = φ.obj a.fst | null | true |
Set.Ioc_eq_Icc_same_iff | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Icc a b ↔ ¬a ≤ b | null | true |
Lean.Parser.Tactic.ImpossibleConfig.rec | Init.Tactics | {motive : Lean.Parser.Tactic.ImpossibleConfig → Sort u} →
((levels : Bool) → motive { levels := levels }) → (t : Lean.Parser.Tactic.ImpossibleConfig) → motive t | null | false |
_private.Lean.Meta.Tactic.Simp.Arith.Int.Basic.0.Lean.Meta.Simp.Arith.Int.ToLinear.toLinearExpr.visit._unsafe_rec | Lean.Meta.Tactic.Simp.Arith.Int.Basic | Lean.Expr → Lean.Meta.Simp.Arith.Int.ToLinear.M Int.Internal.Linear.Expr | null | false |
ArchimedeanClass.stdPart_ofNat | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] (n : ℕ) [inst_3 : n.AtLeastTwo],
ArchimedeanClass.stdPart (OfNat.ofNat n) = ↑n | null | true |
Function.Injective.divInvMonoid._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : Pow M₁ ℕ] [inst_3 : Inv M₁]
[inst_4 : Div M₁] [inst_5 : DivInvMonoid M₂] (f : M₁ → M₂) (hf : Function.Injective f) (one : f 1 = 1)
(mul : ∀ (x y : M₁), f (x * y) = f x * f y),
(∀ (x : M₁), f x⁻¹ = (f x)⁻¹) →
(∀ (x y : M₁), f (x / y)... | null | false |
Lean.Doc.Block.ul.noConfusion | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{P : Sort u_1} →
{items items' : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))} →
Lean.Doc.Block.ul items = Lean.Doc.Block.ul items' → (items ≍ items' → P) → P | null | false |
LinearMap.surjective_comp_linearProjOfIsCompl | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
{M : Type u_6} [inst_3 : AddCommMonoid M] (h : IsCompl p q) [inst_4 : Module R M],
Function.Surjective (p.projectionOnto q h).comp | **Alias** of `LinearMap.surjective_comp_projectionOnto`. | true |
RelIso.embeddingSurjectiveEquivIso | Mathlib.Order.RelIso.Basic | {α : Type u_1} → {β : Type u_2} → {r : α → α → Prop} → {s : β → β → Prop} → { f // Function.Surjective ⇑f } ≃ (r ≃r s) | Surjective relation embeddings are equivalent to relation isomorphisms. | true |
AlgebraicGeometry.Scheme.zeroLocus_iInf | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} {ι : Type u_1} (I : ι → Ideal ↑(X.presheaf.obj (Opposite.op U)))
[Finite ι], X.zeroLocus ↑(⨅ i, I i) = (⋃ i, X.zeroLocus ↑(I i)) ∪ (↑U)ᶜ | null | true |
Set.nonempty_Ioi | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α} [NoMaxOrder α], (Set.Ioi a).Nonempty | null | true |
MonoidAlgebra.mapDomainBialgHomMulEquiv_symm_apply | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} {G : Type u_5} {H : Type u_6} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : CommGroup G]
[inst_3 : CommGroup H] (a : WithConv (MonoidAlgebra R G →ₐc[R] MonoidAlgebra R H)),
MonoidAlgebra.mapDomainBialgHomMulEquiv.symm a = MonoidAlgebra.mapDomainOfBialgHom a.ofConv | null | true |
cond.eq_2 | Init.Grind.Ring.CommSolver | ∀ {α : Sort u} (x y : α), (bif false then x else y) = y | null | true |
_private.Mathlib.Data.Set.Lattice.Order.0.Set.Ici_iSup._simp_1_3 | Mathlib.Data.Set.Lattice.Order | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
IsPrimitiveRoot.zpowers_eq | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [IsDomain R] {k : ℕ} [NeZero k] {ζ : Rˣ},
IsPrimitiveRoot ζ k → Subgroup.zpowers ζ = rootsOfUnity k R | null | true |
LaurentPolynomial.algebraMap_eq_toLaurent | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : CommSemiring R] (f : Polynomial R),
(algebraMap (Polynomial R) (LaurentPolynomial R)) f = Polynomial.toLaurent f | null | true |
FirstOrder.Field.FieldAxiom.toProp.eq_9 | Mathlib.ModelTheory.Algebra.Field.Basic | ∀ (K : Type u_2) [inst : Add K] [inst_1 : Mul K] [inst_2 : Neg K] [inst_3 : Zero K] [inst_4 : One K],
FirstOrder.Field.FieldAxiom.toProp K FirstOrder.Field.FieldAxiom.existsPairNE = ∃ x y, x ≠ y | null | true |
Lean.LibrarySuggestions.Config.maxSuggestions._default | Lean.LibrarySuggestions.Basic | ℕ | null | false |
_private.Aesop.RuleSet.0.Aesop.LocalRuleSet.add._proof_1 | Aesop.RuleSet | ∀ (rs : Aesop.LocalRuleSet) (r : Aesop.NormSimpRule),
0 <
(rs.simpTheoremsArray.modify 0 fun x =>
match x with
| (name, simpTheorems) => (name, Array.foldl Aesop.SimpTheorems.addSimpEntry simpTheorems r.entries)).size | null | false |
List.flatten.match_1 | Init.Prelude | {α : Type u_1} →
(motive : List (List α) → Sort u_2) →
(x : List (List α)) → (Unit → motive []) → ((l : List α) → (L : List (List α)) → motive (l :: L)) → motive x | null | false |
_private.Init.Data.Vector.Erase.0.Vector.eraseIdx_set_lt._proof_1 | Init.Data.Vector.Erase | ∀ {n i : ℕ} {w : i < n} {j : ℕ}, j < i → ¬i - 1 < n - 1 → False | null | false |
RingQuot.Rel.sub_right | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Ring R] {r : R → R → Prop} ⦃a b c : R⦄, RingQuot.Rel r b c → RingQuot.Rel r (a - b) (a - c) | null | true |
Lean.Expr.hasMVar | Lean.Expr | Lean.Expr → Bool | Does the expression contain level (aka universe) or expression metavariables?
This is a constant time operation.
| true |
MDifferentiableOn.differentiableOn | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {f : E → E'}
{s : Set E}, MDiff[s] f → DifferentiableOn 𝕜 f s | **Alias** of the forward direction of `mdifferentiableOn_iff_differentiableOn`.
---
For maps between vector spaces, `MDifferentiableOn` and `DifferentiableOn` coincide | true |
NumberField.InfinitePlace.Completion.instNormedField._proof_10 | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} [inst : Field K] (v : NumberField.InfinitePlace K),
autoParam (∀ (x : v.Completion), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
Complex.HadamardThreeLines.sSupNormIm.eq_1 | Mathlib.Analysis.Complex.Hadamard | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : ℂ → E) (x : ℝ),
Complex.HadamardThreeLines.sSupNormIm f x = sSup (norm ∘ f '' Complex.re ⁻¹' {x}) | null | true |
String.Slice.contains_prop_eq | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice}, s.contains p = s.copy.toList.any fun b => decide (p b) | null | true |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_nhds._simp_1_1 | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} [inst : TopologicalSpace X], T2Space X = Pairwise fun x y => Disjoint (nhds x) (nhds y) | null | false |
CategoryTheory.Adjunction.Quadruple.epi_leftTriple_rightToLeft_app_iff_mono_rightTriple_leftToRight_app | Mathlib.CategoryTheory.Adjunction.Quadruple | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {G : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor D C} (q : CategoryTheory.Adjunction.Quadruple L F G R) [inst_2 : F.Fu... | For an adjoint quadruple `L ⊣ F ⊣ G ⊣ R` where `F` (and hence also `R`) is fully faithful, all
components of the natural transformation `G ⟶ L` are epimorphisms iff all components of the natural
transformation `F ⟶ R` are monomorphisms. | true |
Std.TreeSet.Equiv.rec | Std.Data.TreeSet.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{m₁ m₂ : Std.TreeSet α cmp} →
{motive : m₁.Equiv m₂ → Sort u_1} → ((inner : m₁.inner.Equiv m₂.inner) → motive ⋯) → (t : m₁.Equiv m₂) → motive t | null | false |
_private.Mathlib.NumberTheory.LSeries.Positivity.0.LSeries.iteratedDeriv_alternating._simp_1_2 | Mathlib.NumberTheory.LSeries.Positivity | ∀ {x : ℝ}, (0 ≤ ↑x) = (0 ≤ x) | null | false |
List.tail_attachWith | Init.Data.List.Attach | ∀ {α : Type u_1} {P : α → Prop} {xs : List α} {H : ∀ a ∈ xs, P a}, (xs.attachWith P H).tail = xs.tail.attachWith P ⋯ | null | true |
CategoryTheory.ShortComplex.HomologyMapData.noConfusionType | Mathlib.Algebra.Homology.ShortComplex.Homology | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.HomologyData} →
{h₂ : S₂.HomologyData} →
CategoryTheory.S... | null | false |
ProofWidgets.Component.mk.noConfusion | ProofWidgets.Component.Basic | {Props : Type} →
{P : Sort u} →
{toModule : Lean.Widget.Module} →
{«export» : String} →
{toModule' : Lean.Widget.Module} →
{export' : String} →
{ toModule := toModule, «export» := «export» } = { toModule := toModule', «export» := export' } →
(toModule = toModule' ... | null | false |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.IsComplex._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i : ℕ), ¬i ≤ i + 1 → False | null | false |
Algebra.GrothendieckGroup.lift._proof_3 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] (f : M →* G) (x : ↥⊤), IsUnit (f ↑x) | null | false |
SeparationQuotient.continuousWithinAt_lift | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x : X} {f : X → Y}
{hf : ∀ (x y : X), Inseparable x y → f x = f y} {s : Set (SeparationQuotient X)},
ContinuousWithinAt (SeparationQuotient.lift f hf) s (SeparationQuotient.mk x) ↔
ContinuousWithinAt f (SeparationQuotient... | null | true |
instNegUniformOnFun._aux_1 | Mathlib.Topology.Algebra.UniformConvergence | {α : Type u_1} → {β : Type u_2} → {𝔖 : Set (Set α)} → [Neg β] → UniformOnFun α β 𝔖 → UniformOnFun α β 𝔖 | null | false |
CategoryTheory.Limits.BinaryBicone.category._proof_14 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} {X Y Z : CategoryTheory.Limits.BinaryBicone P Q} (f : CategoryTheory.Limits.BinaryBiconeMorphism X Y)
(g : CategoryTheory.Limits.BinaryBiconeMorphism Y Z),
CategoryTheory.CategoryStruct.com... | null | false |
groupHomology.cyclesIso₀_inv_comp_iCycles_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (x : ↑A),
(CategoryTheory.ConcreteCategory.hom (groupHomology.iCycles A 0))
((CategoryTheory.ConcreteCategory.hom (groupHomology.cyclesIso₀ A).inv) x) =
(CategoryTheory.ConcreteCategory.hom (groupHomology.chainsIso₀ A).inv) x | null | true |
Std.Do.SPred.and_nil | Std.Do.SPred.SPred | ∀ {P Q : Std.Do.SPred []}, spred(P ∧ Q) = { down := P.down ∧ Q.down } | null | true |
EuclideanGeometry.Sphere.polar_eq_orthRadius_self_iff._simp_1 | Mathlib.Geometry.Euclidean.Sphere.PolePolar | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P},
0 ≤ s.radius → ∀ {p : P}, (s.polar p = s.orthRadius p) = (p ∈ s ∨ p = s.center) | null | false |
Stonean.fullyFaithfulToCompHaus._proof_1 | Mathlib.Topology.Category.Stonean.Basic | ∀ (X : CompHausLike fun X => ExtremallyDisconnected ↑X), ExtremallyDisconnected ↑X.toTop → True | null | false |
Rack.PreEnvelGroup | Mathlib.Algebra.Quandle | Type u → Type u | Free generators of the enveloping group.
| true |
Std.DHashMap.get!_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] {a : α} [inst_1 : Inhabited (β a)],
∅.get! a = default | null | true |
Vector.forall_cons_iff | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {P : Vector α (n + 1) → Prop},
(∀ (xs : Vector α (n + 1)), P xs) ↔ ∀ (x : α) (xs : Vector α n), P (xs.push x) | null | true |
MonoidHom.bijective_of_bijective_of_injective_of_left_exact | Mathlib.Algebra.FiveLemma | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {M₃ : Type u_3} {N₁ : Type u_6} {N₂ : Type u_7} {N₃ : Type u_8} [inst : Group M₁]
[inst_1 : Group M₂] [inst_2 : Group M₃] [inst_3 : Group N₁] [inst_4 : Group N₂] [inst_5 : Group N₃] (f₁ : M₁ →* M₂)
(f₂ : M₂ →* M₃) (g₁ : N₁ →* N₂) (g₂ : N₂ →* N₃) (i₁ : M₁ →* N₁) (i₂ : M₂ →* N₂) (i₃ ... | A special case of the five lemma in terms of groups. For a diagram explaining the
variables, see the module docstring. | true |
DirectLimit.instNonAssocSemiringOfRingHomClass._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
_private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.signAux_swap._simp_1_3 | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
IsBoundedLinearMap.differentiableWithinAt | Mathlib.Analysis.Calculus.FDeriv.Linear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E}, IsBoundedLinearMap 𝕜 f → DifferentiableWithinAt 𝕜 f s x | null | true |
Polynomial.eq_neg_mul_add_of_roots_quadratic_eq_pair | Mathlib.RingTheory.Polynomial.SmallDegreeVieta | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {a b c x1 x2 : R},
(Polynomial.C a * Polynomial.X ^ 2 + Polynomial.C b * Polynomial.X + Polynomial.C c).roots = {x1, x2} →
b = -a * (x1 + x2) | **Vieta's formula** for quadratics. | true |
_private.Lean.Meta.Tactic.Util.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.Util.2566314605._hygCtx._hyg.4 | Lean.Meta.Tactic.Util | IO (Lean.Option Bool) | null | false |
CategoryTheory.Limits.Fork.ι_postcompose | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g f' g' : X ⟶ Y}
{α : CategoryTheory.Limits.parallelPair f g ⟶ CategoryTheory.Limits.parallelPair f' g'}
{c : CategoryTheory.Limits.Fork f g},
CategoryTheory.Limits.Fork.ι ((CategoryTheory.Limits.Cone.postcompose α).obj c) =
CategoryTheory.... | null | true |
Manifold.IsImmersionOfComplement.of_opens | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_11}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {n : WithTop ℕ∞} [IsManifold I n M]
... | null | true |
Std.ExtDHashMap.size_erase | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m.erase k).size = if k ∈ m then m.size - 1 else m.size | null | true |
Set.Ico_inter_Iio | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a b ∩ Set.Iio c = Set.Ico a (min b c) | null | true |
_private.Mathlib.Data.Num.Lemmas.0.Num.castNum_shiftLeft._simp_1_1 | Mathlib.Data.Num.Lemmas | ∀ (p : Num) (n : ℕ), p <<< n = p.shiftl n | null | false |
Lean.Compiler.LCNF.PP.ppLetDecl | Lean.Compiler.LCNF.PrettyPrinter | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LetDecl pu → Lean.Compiler.LCNF.PP.M Std.Format | null | true |
TopologicalSpace.CompactOpens.instGeneralizedBooleanAlgebra._proof_4 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : T2Space α] (x y z : TopologicalSpace.CompactOpens α),
(x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
Set.union_diff_distrib | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t u : Set α}, (s ∪ t) \ u = s \ u ∪ t \ u | **Alias** of `Set.union_sdiff_distrib`. | true |
_private.Std.Data.String.ToInt.0.String.isSome_toInt?._simp_1_1 | Std.Data.String.ToInt | ∀ {s : String}, s.toInt? = s.toSlice.toInt? | null | false |
SSet.Truncated.Edge.mk'._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | ∀ {X : SSet.Truncated 2} (s : X.obj (Opposite.op { obj := { len := 1 }, property := SSet.Truncated.Edge._proof_2 })),
(CategoryTheory.ConcreteCategory.hom
(X.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op))
s =
(CategoryTheory.ConcreteCategory.hom
... | null | false |
ModelWithCorners.MfldCat.isoOfDiffeomorph._proof_2 | Mathlib.Geometry.Manifold.Category.MfldCat.OfModel | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_2} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{M N : I.MfldCat n} (e : Diffeomorph I I (↑M) (↑N) n),
CategoryTheory.CategoryStruct.comp (Mo... | null | false |
Mathlib.Tactic.rename' | Mathlib.Tactic.Rename | Lean.ParserDescr | `rename' h => hnew` renames the hypothesis named `h` to `hnew`.
To rename several hypothesis, use `rename' h₁ => h₁new, h₂ => h₂new`.
You can use `rename' a => b, b => a` to swap two variables. | true |
Frm.instCoeSortType | Mathlib.Order.Category.Frm | CoeSort Frm (Type u_1) | null | true |
Ideal.bot_isMaximal | Mathlib.RingTheory.Ideal.Maximal | ∀ {K : Type u} [inst : DivisionSemiring K], ⊥.IsMaximal | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.