name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContDiffMapSupportedIn.compact_supp | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
HasCompactSupport ⇑f | null | true |
CategoryTheory.instRepresentablyCoflatIndYoneda | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], CategoryTheory.RepresentablyCoflat CategoryTheory.Ind.yoneda | null | true |
Module.Relations.instAddCommGroupQuotient._aux_3 | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u_3} →
[inst : Ring A] → (relations : Module.Relations A) → relations.Quotient → relations.Quotient → relations.Quotient | null | false |
_private.Mathlib.Order.WellFounded.0.exists_not_acc_lt_of_not_acc._simp_1_1 | Mathlib.Order.WellFounded | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
lt_of_mul_lt_mul_left | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [PosMulReflectLT α],
a * b < a * c → 0 ≤ a → b < c | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_diff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} [Finite ι] {s₁ s₂ : Set (ι → ℕ)}, IsSemilinearSet s₁ → IsSemilinearSet s₂ → IsSemilinearSet (s₁ \ s₂) | **Alias** of `_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_sdiff`. | true |
CompleteLattice.MulticoequalizerDiagram.multicofork._proof_1 | Mathlib.Order.CompleteLattice.MulticoequalizerDiagram | ∀ {T : Type u_1} [inst : CompleteLattice T] {ι : Type u_2} {x : T} {u : ι → T} {v : ι → ι → T}
(d : CompleteLattice.MulticoequalizerDiagram x u v) (x_1 : (CategoryTheory.Limits.MultispanShape.prod ι).L),
d.multispanIndex.right ((CategoryTheory.Limits.MultispanShape.prod ι).fst x_1) ≤ x | null | false |
Sym2.instDecidableRel._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x x_1 : α × α),
Sym2.Rel α (x.1, x.2) (x_1.1, x_1.2) ↔ x.1 = x_1.1 ∧ x.2 = x_1.2 ∨ x.1 = x_1.2 ∧ x.2 = x_1.1 | null | false |
Lean.Meta.Sym.ProofInstInfo.noConfusionType | Lean.Meta.Sym.SymM | Sort u → Lean.Meta.Sym.ProofInstInfo → Lean.Meta.Sym.ProofInstInfo → Sort u | null | false |
Algebra.adjoin_mono | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s t : Set A},
s ⊆ t → Algebra.adjoin R s ≤ Algebra.adjoin R t | null | true |
ValuationSubring.instIsScalarTowerSubtypeMemValuationSubringWithZeroMultiplicativeInt | Mathlib.RingTheory.Valuation.AlgebraInstances | ∀ {K : Type u_1} [inst : Field K] (v : Valuation K (WithZero (Multiplicative ℤ))) (L : Type u_2) [inst_1 : Field L]
[inst_2 : Algebra K L] (E : Type u_3) [inst_3 : Field E] [inst_4 : Algebra K E] [inst_5 : Algebra L E]
[IsScalarTower K L E], IsScalarTower (↥v.valuationSubring) L E | null | true |
Matrix.rowScale_apply_diag_of_ne | Mathlib.LinearAlgebra.Matrix.ElementaryRowOperations | ∀ {R : Type u_1} {m : Type u_2} [inst : DecidableEq m] [inst_1 : Zero R] [inst_2 : One R] {i a : m},
a ≠ i → ∀ (c : R), Matrix.rowScale i c a a = 1 | null | true |
Array.swap_perm | Init.Data.Array.Perm | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ} (h₁ : i < xs.size) (h₂ : j < xs.size), (xs.swap i j h₁ h₂).Perm xs | null | true |
HomologicalComplex.HomologySequence.snakeInput._proof_1 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_3} {ι : Type u_1} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} (i : ι), (HomologicalComplex.homologyFunctor C c i).PreservesZeroMorphisms | null | false |
Std.TreeMap.Raw.getElem!_filter | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {f : α → β → Bool} {k : α} (h : t.WF),
(Std.TreeMap.Raw.filter f t)[k]! = (t[k]?.pfilter fun x h' => f (t.getKey k ⋯) x).get! | null | true |
ConvexCone.closure_eq | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] {E : Type u_2} [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : SMul 𝕜 E] [inst_6 : ContinuousConstSMul 𝕜 E]
{K L : ConvexCone 𝕜 E}, K.closure = L ↔ closure ↑K = ↑L | null | true |
SSet.Subcomplex.liftPath._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet} (A : X.Subcomplex) {n : ℕ} (p : X.Path n),
(∀ (j : Fin (n + 1)), p.vertex j ∈ A.obj (Opposite.op { len := 0 })) →
∀ (j : Fin n), p.vertex j.castSucc ∈ A.obj (Opposite.op { len := 0 }) | null | false |
SummationFilter.mk.sizeOf_spec | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_4} [inst : SizeOf β] (filter : Filter (Finset β)), sizeOf { filter := filter } = 1 + sizeOf filter | null | true |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.instLawfulUpwardEnumerableLTOfLawfulUpwardEnumerableOfLawfulUpwardEnumerableLEOfLawfulOrderLT._simp_1 | Init.Data.Range.Polymorphic.Instances | ∀ {α : Type u} {inst : LT α} {inst_1 : LE α} [self : Std.LawfulOrderLT α] (a b : α), (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
Matrix.IsSymm.transpose | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.IsSymm → A.transpose.IsSymm | null | true |
ENNReal.add_div | Mathlib.Basic.ENNReal.Inv | ∀ {a b c : ENNReal}, (a + b) / c = a / c + b / c | null | true |
Lean.Elab.Tactic.evalInhabit | Mathlib.Tactic.Inhabit | Lean.MVarId → Option Lean.Ident → Lean.Syntax → Lean.Elab.Tactic.TacticM Lean.MVarId | `evalInhabit` takes in the MVarId of the main goal, runs the core portion of the inhabit tactic,
and returns the resulting MVarId | true |
Equiv.distribLattice._proof_2 | Mathlib.Order.Lattice | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : DistribLattice β] {x y : α}, e x < e y ↔ e x < e y | null | false |
Lean.Meta.SolveByElim.SolveByElimConfig.maxDepth._default | Lean.Meta.Tactic.SolveByElim | ℕ | null | false |
SSet.Edge.InvStruct.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | {X : SSet} →
{x₀ x₁ : X.obj (Opposite.op { len := 0 })} →
{hom : SSet.Edge x₀ x₁} →
{motive : hom.InvStruct → Sort u_1} →
((inv : SSet.Edge x₁ x₀) →
(homInvId : hom.CompStruct inv (SSet.Edge.id x₀)) →
(invHomId : inv.CompStruct hom (SSet.Edge.id x₁)) →
motiv... | null | false |
List.prev._unsafe_rec | Mathlib.Data.List.Cycle | {α : Type u_1} → [DecidableEq α] → (l : List α) → (x : α) → x ∈ l → α | null | false |
Nucleus.instCompleteLattice._proof_1 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : CompleteLattice X] (a b : Nucleus X), a ≤ SemilatticeSup.sup a b | null | false |
Nat.castEmbedding | Mathlib.Algebra.Ring.CharZero | {R : Type u_2} → [inst : AddMonoidWithOne R] → [CharZero R] → ℕ ↪ R | `Nat.cast` as an embedding into monoids of characteristic `0`. | true |
_private.Init.Data.Range.Polymorphic.BitVec.0.BitVec.succ?_eq_some._simp_1_4 | Init.Data.Range.Polymorphic.BitVec | ∀ {β : Type u_1} {a : β} {p : Prop} {x : Decidable p} {b : Option β},
((if p then none else b) = some a) = (¬p ∧ b = some a) | null | false |
isLeftRegular_iff_isRegular | Mathlib.Algebra.Group.Semigroup | ∀ {G : Type u_1} [inst : CommMagma G] {a : G}, IsLeftRegular a ↔ IsRegular a | null | true |
_private.Init.Data.String.Substring.0.Substring.Raw.get.match_1.eq_1 | Init.Data.String.Substring | ∀ (motive : Substring.Raw → String.Pos.Raw → Sort u_1) (s : String) (b stopPos p : String.Pos.Raw)
(h_1 : (s : String) → (b stopPos p : String.Pos.Raw) → motive { str := s, startPos := b, stopPos := stopPos } p),
(match { str := s, startPos := b, stopPos := stopPos }, p with
| { str := s, startPos := b, stopPos... | null | true |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.isSelfAdjoint_ringInverse_iff._proof_1_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {A : Type u_1} {a : A} [inst : Semiring A] [inst_1 : StarRing A],
IsUnit a → IsSelfAdjoint (Ring.inverse a) → IsSelfAdjoint a | null | false |
Std.TreeMap.Raw.Equiv.of_toArray_perm | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp},
t₁.toArray.Perm t₂.toArray → t₁.Equiv t₂ | null | true |
MeasureTheory.AddContent.isCaratheodory_inducedOuterMeasure_of_mem | Mathlib.MeasureTheory.OuterMeasure.OfAddContent | ∀ {α : Type u_1} {C : Set (Set α)} (hC : MeasureTheory.IsSetSemiring C) (m : MeasureTheory.AddContent ENNReal C)
{s : Set α}, s ∈ C → (MeasureTheory.inducedOuterMeasure (fun x x_1 => m x) ⋯ ⋯).IsCaratheodory s | Every `s ∈ C` for an `m : AddContent C` with `IsSetSemiring C` is Carathéodory measurable
with respect to the `inducedOuterMeasure` from `m`. | true |
FiniteMulArchimedeanClass.mk._proof_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] (a : M),
a ≠ 1 → ¬MulArchimedeanClass.mk a = ⊤ | null | false |
IsUnital.toCommRing._proof_12 | Mathlib.Algebra.Ring.Defs | ∀ {A : Type u_1} [inst : NonUnitalCommRing A] (a : A), a * 0 = 0 | null | false |
List.decidableLE._proof_1 | Init.Data.List.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : LT α] [inst_2 : DecidableLT α] (l₁ l₂ : List α),
(!decide (l₂ < l₁)).Reflects ¬l₂ < l₁ | null | false |
FreeAddMonoid.length_eq_zero | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {a : FreeAddMonoid α}, a.length = 0 ↔ a = 0 | null | true |
Lean.Meta.SolveByElim.ApplyRulesConfig.ctorIdx | Lean.Meta.Tactic.SolveByElim | Lean.Meta.SolveByElim.ApplyRulesConfig → ℕ | null | false |
_private.ImportGraph.WorkspaceModel.Summary.Cache.0.ImportGraph.Lake.WorkspaceSummary.isUpToDate.match_1 | ImportGraph.WorkspaceModel.Summary.Cache | (motive : Option System.FilePath → Sort u_1) →
(wsDir? : Option System.FilePath) →
((wsDir : System.FilePath) → motive (some wsDir)) → ((x : Option System.FilePath) → motive x) → motive wsDir? | null | false |
eq_one_of_mul_le_one_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : PartialOrder α] [MulLeftMono α],
1 ≤ a → 1 ≤ b → a * b ≤ 1 → a = 1 | null | true |
LinearMap.lift_rank_comap_le | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} {M' : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M']
[inst_3 : Module R M] [inst_4 : Module R M'] [HasRankNullity.{u, u_1} R] {f : M →ₗ[R] M'} (p : Submodule R M'),
Cardinal.lift.{v, u} (Module.rank R ↥(Submodule.comap f p)) ≤
Cardinal.lift.{u, v} (Mod... | null | true |
List.Perm.foldl_eq' | Init.Data.List.Perm | ∀ {β : Type u_1} {α : Type u_2} {f : β → α → β} {l₁ l₂ : List α},
l₁.Perm l₂ →
(∀ x ∈ l₁, ∀ y ∈ l₁, ∀ (z : β), f (f z x) y = f (f z y) x) →
∀ (init : β), List.foldl f init l₁ = List.foldl f init l₂ | This theorem is a variant of `Perm.foldl_eq` defined in Mathlib which uses typeclasses rather
than the explicit `comm` argument.
| true |
Affine.Simplex.sign_excenterWeights_singleton_pos | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) [n.AtLeastTwo]
{i j : Fin (n + 1)}, i ≠ j → SignType.sign (s.excenterWeights {i} j) = 1 | null | true |
Std.Internal.Parsec.String.take | Std.Internal.Parsec.String | ℕ → Std.Internal.Parsec.String.Parser String | Takes a fixed amount of chars from the iterator.
| true |
ContinuousLinearEquiv.continuousAlternatingMapCongrRightEquiv | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_4} →
{N' : Type u_5} →
{ι : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace M] →
[inst_4 : AddCommMonoid N] →
... | A continuous linear equivalence of codomains
defines an equivalence between continuous alternating maps. | true |
Lean.SMap.find? | Lean.Data.SMap | {α : Type u} → {β : Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.SMap α β → α → Option β | null | true |
Polynomial.exists_monic_irreducible_factor | Mathlib.RingTheory.Polynomial.UniqueFactorization | ∀ {F : Type u_1} [inst : Field F] (f : Polynomial F), ¬IsUnit f → ∃ g, g.Monic ∧ Irreducible g ∧ g ∣ f | A polynomial over a field which is not a unit must have a monic irreducible factor.
See also `WfDvdMonoid.exists_irreducible_factor`. | true |
_private.Init.Data.List.Sublist.0.List.Sublist.trans.match_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₂ : List α} (a : α) (motive : (l₂' l₁ : List α) → l₁.Sublist l₂' → a :: l₂ = l₂' → Prop)
(l₂' l₁ : List α) (h₁ : l₁.Sublist l₂') (e : a :: l₂ = l₂'),
(∀ (e : a :: l₂ = []), motive [] [] ⋯ e) →
(∀ (l₁ l₂_1 : List α) (a' : α) (h₁' : l₁.Sublist l₂_1) (e : a :: l₂ = a' :: l₂_1), motive (a' :: l₂_... | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchDiagnostics.0.Lean.Meta.Grind.InstGraph.mk.inj | Lean.Meta.Tactic.Grind.EMatchDiagnostics | ∀ {info info_1 : Std.HashMap Lean.Meta.Grind.EMatchDiagNode Lean.Meta.Grind.NodeInfo✝},
{ info := info } = { info := info_1 } → info = info_1 | null | true |
Std.DTreeMap.Internal.Impl.WF.below.insert | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced} {k : α} {v : x k} (a : t.WF),
Std.DTreeMap.Internal.Impl.WF.below a → motive t a → Std.DTreeMap.Internal.Impl.WF.below ⋯ | null | true |
HomologicalComplex.exactAt_iff_isZero_homology | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i : ι) [inst_2 : K.HasHomology i],
K.ExactAt i ↔ CategoryTheory.Limits.IsZero (K.homology i) | null | true |
_private.Mathlib.Tactic.Determinant.Bird.Cert.0.Mathlib.Tactic.Determinant.certEntry._proof_1 | Mathlib.Tactic.Determinant.Bird.Cert | ∀ {u : Lean.Level} {α : Q(Type u)} {rα : Q(CommRing «$α»)} (i j dim : ℕ) (dimLit : Q(ℕ)) (A : Q(Array «$α»))
(arrayEntries : Array Q(«$α»)),
let casesOn_1 :=
Bool.casesOn (motive := fun x => x.Reflects (dim * i + j < arrayEntries.size) → Q(«$α»))
(decide (dim * i + j < arrayEntries.size)) (fun x => q(0)) ... | null | false |
CochainComplex.mappingCone.lift.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
(α α_1 : CochainComplex.HomComplex.Cocycle K F 1) (e_α : α = α_1) (β β_1 : CochainComplex.HomComplex... | null | true |
Lean.Compiler.LCNF.Simp.Config.etaPoly._default | Lean.Compiler.LCNF.Simp.Config | Bool | null | false |
Pi.eq_bot_iff_irrefl_of_subsingleton._simp_1 | Mathlib.Order.PropInstances | ∀ {α : Type u_2} [Subsingleton α] {r : α → α → Prop}, (r = ⊥) = Std.Irrefl r | null | false |
_private.Lean.Elab.Calc.0.Lean.Elab.Term.annotateFirstHoleWithType.go | Lean.Elab.Calc | Lean.Expr → Lean.Syntax → StateT Bool Lean.Elab.TermElabM Lean.Syntax | null | true |
HopfAlgCat.Hom.toBialgHom | Mathlib.Algebra.Category.HopfAlgCat.Basic | {R : Type u} → [inst : CommRing R] → {X Y : HopfAlgCat R} → X.Hom Y → X.carrier →ₐc[R] Y.carrier | Turn a morphism in `HopfAlgCat` back into a `BialgHom`. | true |
_private.Init.Data.Range.Polymorphic.UInt.0.UInt8.instLawfulHasSize._simp_2 | Init.Data.Range.Polymorphic.UInt | ∀ {a b : UInt8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
AddGrpCat.FilteredColimits.colimitAddGroup._proof_2 | Mathlib.Algebra.Category.Grp.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J AddGrpCat) (a : ↑(AddGrpCat.FilteredColimits.G F)), 0 • a = 0 | null | false |
_private.Mathlib.Algebra.Polynomial.Bivariate.0.Polynomial.Bivariate.swap_monomial._simp_1_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | null | false |
_private.Mathlib.RingTheory.Extension.Generators.0.Algebra.Generators.map_toComp_ker._simp_1_6 | Mathlib.RingTheory.Extension.Generators | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
Mathlib.Tactic.GCongr.Context._sizeOf_1 | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.Context → ℕ | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.equivAux._proof_4 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H' : Type u_2} [inst_1 : NormedAddCommGroup H'] [inst_2 : InnerProductSpace 𝕜 H'],
IsBoundedSMul 𝕜 H' | null | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.applyCell_eq_apply_toListModel._simp_1_5 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
DirectSum.«_aux_Mathlib_Algebra_DirectSum_Basic___macroRules_DirectSum_term⨁_,__1» | Mathlib.Algebra.DirectSum.Basic | Lean.Macro | null | false |
Complex.sin_nat_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℕ), Complex.sin (↑n * ↑Real.pi) = 0 | null | true |
ConjAct.unitsMulSemiringAction | Mathlib.Algebra.Ring.Action.ConjAct | {R : Type u_1} → [inst : Semiring R] → MulSemiringAction (ConjAct Rˣ) R | null | true |
Lean.MessageData.kind._unsafe_rec | Lean.Message | Lean.MessageData → Lean.Name | null | false |
Std.Time.instFormatGenericFormatFormatTypeString | Std.Time.Format.Basic | {aw : Std.Time.Awareness} → Std.Time.Format (Std.Time.GenericFormat aw) fun x1 x2 => Std.Time.FormatType x1 x2.string | null | true |
SimplexCategory.mono_iff_injective | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n m : SimplexCategory} {f : n ⟶ m}, CategoryTheory.Mono f ↔ Function.Injective ⇑(SimplexCategory.Hom.toOrderHom f) | A morphism in `SimplexCategory` is a monomorphism precisely when it is an injective function
| true |
SimpleGraph.IsAcyclic.induce | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V}, G.IsAcyclic → ∀ (s : Set V), (SimpleGraph.induce s G).IsAcyclic | A graph induced from an acyclic graph is acyclic. | true |
AddRightCancelMonoid.recOn | Mathlib.Algebra.Group.Monoid | {M : Type u_2} →
{motive : AddRightCancelMonoid M → Sort u} →
(t : AddRightCancelMonoid M) →
([toAddMonoid : AddMonoid M] →
[toIsRightCancelAdd : IsRightCancelAdd M] →
motive { toAddMonoid := toAddMonoid, toIsRightCancelAdd := toIsRightCancelAdd }) →
motive t | null | false |
CategoryTheory.Functor.projective_of_map_projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor C D) [F.Full] [F.Faithful] [F.PreservesEpimorphisms] {P : C},
CategoryTheory.Projective (F.obj P) → CategoryTheory.Projective P | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Flat.0.AlgebraicGeometry.isIso_pushoutSection_iff._proof_1_1 | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | null | false |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.getElem?_toArray_rcc_eq_some_iff._simp_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValue?_eq_some_iff_exists_beq_and_mem_toList._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} {k : α} {v : β} {l : List ((_ : α) × β)},
((k, v) ∈ List.map (fun x => (x.fst, x.snd)) l) = (⟨k, v⟩ ∈ l) | null | false |
ByteArray.get_extract_aux | Batteries.Data.ByteArray | ∀ {i : ℕ} {a : ByteArray} {start stop : ℕ}, i < (a.extract start stop).size → start + i < a.size | null | true |
_private.Lake.Util.Version.0.Lake.VerRange.parseM.match_3 | Lake.Util.Version | (s : String) →
(motive : EStateM.Result String s.Pos Lake.VerComparator → Sort u_1) →
(x : EStateM.Result String s.Pos Lake.VerComparator) →
((cmp : Lake.VerComparator) → (p : s.Pos) → motive (EStateM.Result.ok cmp p)) →
((e : String) → (p : s.Pos) → motive (EStateM.Result.error e p)) → motive x | null | false |
RelIso.swapEquiv_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s), RelIso.swapEquiv f = f.swap | null | true |
Std.ExtTreeMap.getKey!_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k a : α} {v : β}, (t.insert k v).getKey! a = if cmp k a = Ordering.eq then k else t.getKey! a | null | true |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_17 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : (PreQuasiregular A)ˣ),
{
val :=
PreQuasiregular.equiv
(↑↑⟨{ val := 1 + ↑(PreQuasiregular.equiv.symm ↑x), inv := 1 + ... | null | false |
ConjClasses.instDecidableEqOfDecidableRelIsConj._aux_1 | Mathlib.Algebra.Group.Conj | {α : Type u_1} → [inst : Monoid α] → [DecidableRel IsConj] → DecidableEq (ConjClasses α) | null | false |
CategoryTheory.ShortComplex.SnakeInput.epi_v₂₃_τ₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Epi S.v₂₃.τ₂ | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.chainTopCoeff_if_one_zero._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.Smooth.0.AlgebraicGeometry.instHasRingHomPropertySmoothOfRelativeDimensionLocallyIsStandardSmoothOfRelativeDimension._proof_5 | Mathlib.AlgebraicGeometry.Morphisms.Smooth | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (w : TopologicalSpace.Opens ↥Y)
(left_1 : AlgebraicGeometry.IsAffineOpen w) (w_1 : TopologicalSpace.Opens ↥X) (a : w_1 ∈ X.affineOpens),
w_1 ≤ (TopologicalSpace.Opens.map f.base).obj w → ↑⟨w_1, ⋯⟩ ≤ (TopologicalSpace.Opens.map f.base).obj ↑⟨w, ⋯⟩ | null | false |
Real.le_logb_iff_rpow_le | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x y : ℝ}, 1 < b → 0 < y → (x ≤ Real.logb b y ↔ b ^ x ≤ y) | null | true |
CategoryTheory.ExactFunctor.whiskeringLeft._proof_3 | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ (C : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} C] (D : Type u_3)
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
(F : C ⥤ₑ D) (G : D ⥤ₑ E),
CategoryTheory.leftExactFunctor C E
(((CategoryTheory.ExactFunctor.forget D E).comp ((Catego... | null | false |
_private.Mathlib.Analysis.SpecificLimits.Basic.0.ENNReal.tendsto_pow_atTop_nhds_top_iff._simp_1_5 | Mathlib.Analysis.SpecificLimits.Basic | ∀ {a : ENNReal} {n : ℕ}, a⁻¹ ^ n = (a ^ n)⁻¹ | null | false |
CommRingCat.limitCommRing._proof_45 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J CommRingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
AddSubmonoid.instCompleteLattice._proof_5 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b : AddSubmonoid M), a ≤ b → b ≤ a → a = b | null | false |
CategoryTheory.RegularMono.lift' | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y W : C} →
{f : X ⟶ Y} →
(hf : CategoryTheory.RegularMono f) →
(k : W ⟶ Y) →
CategoryTheory.CategoryStruct.comp k hf.left = CategoryTheory.CategoryStruct.comp k hf.right →
{ l // CategoryTheory.Categ... | If `f` is a regular mono, then any map `k : W ⟶ Y` equalizing `RegularMono.left` and
`RegularMono.right` induces a morphism `l : W ⟶ X` such that `l ≫ f = k`. | true |
Algebra.FormallySmooth.kerCotangentToTensor_injective_iff | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {P : Type u_2}
[inst_3 : CommRing P] [inst_4 : Algebra R P] [Algebra.FormallySmooth R P] [inst_6 : Algebra P A]
[IsScalarTower R P A],
Function.Surjective ⇑(algebraMap P A) →
(Function.Injective ⇑(KaehlerDifferential.... | null | true |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.noConfusion | Mathlib.AlgebraicGeometry.RelativeGluing | {P : Sort u_3} →
{S : AlgebraicGeometry.Scheme} →
{𝒰 : S.OpenCover} →
{inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀} →
{inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰} →
{t : AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰} →
{S' : AlgebraicGeometry.Scheme}... | null | false |
Finset.subtype_eq_univ._simp_1 | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {s : Finset α} {p : α → Prop} [inst : DecidablePred p] [inst_1 : Fintype { a // p a }],
(Finset.subtype p s = Finset.univ) = ∀ ⦃a : α⦄, p a → a ∈ s | null | false |
CategoryTheory.Limits.spanCompIso_hom_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z),
(CategoryTheory.Limits.spanCompIso F f g).hom.app CategoryTheory.Limits.WalkingSpan.zero =
CategoryTheory.CategoryStruct.id
... | null | true |
Set.Ici_inter_Ici | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : SemilatticeSup α] {a b : α}, Set.Ici a ∩ Set.Ici b = Set.Ici (a ⊔ b) | null | true |
Vector.map_id'' | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {f : α → α}, (∀ (x : α), f x = x) → ∀ (xs : Vector α n), Vector.map f xs = xs | Variant of `map_id`, with a side condition that the function is pointwise the identity. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Zarankiewicz.0.SimpleGraph.zarankiewicz_of_fintypeCard_eq.match_1_5 | Mathlib.Combinatorics.SimpleGraph.Extremal.Zarankiewicz | ∀ {m n s t : ℕ} (G : SimpleGraph (Fin m ⊕ Fin n))
(motive : G ≤ completeBipartiteGraph (Fin m) (Fin n) ∧ (completeBipartiteGraph (Fin s) (Fin t)).Free G → Prop)
(h : G ≤ completeBipartiteGraph (Fin m) (Fin n) ∧ (completeBipartiteGraph (Fin s) (Fin t)).Free G),
(∀ (h_le : G ≤ completeBipartiteGraph (Fin m) (Fin n)... | null | false |
Units.mk_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ) (y : α) (h₁ : ↑u * y = 1) (h₂ : y * ↑u = 1),
{ val := ↑u, inv := y, val_inv := h₁, inv_val := h₂ } = u | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.