name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Arrow.finite | Mathlib.CategoryTheory.Comma.CardinalArrow | ∀ {C : Type u} [inst : CategoryTheory.SmallCategory C] [CategoryTheory.FinCategory C], Finite (CategoryTheory.Arrow C) | null | true |
Stream'.WSeq.destruct.eq_1 | Mathlib.Data.WSeq.Basic | ∀ {α : Type u},
Stream'.WSeq.destruct =
Computation.corec fun s =>
match Stream'.Seq.destruct s with
| none => Sum.inl none
| some (none, s') => Sum.inr s'
| some (some a, s') => Sum.inl (some (a, s')) | null | true |
SimpleGraph.isClique_map_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {f : α ↪ β} {t : Set β},
(SimpleGraph.map (⇑f) G).IsClique t ↔ t.Subsingleton ∨ ∃ s, G.IsClique s ∧ ⇑f '' s = t | null | true |
_private.Mathlib.Data.List.Lattice.0.List.bagInter.match_1.splitter._sparseCasesOn_3 | Mathlib.Data.List.Lattice | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Array.getElem_reverse | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} (hi : i < xs.reverse.size), xs.reverse[i] = xs[xs.size - 1 - i] | null | true |
IsAddUnit.coe_liftRight | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_3} {N : Type u_4} [inst : AddMonoid M] [inst_1 : AddMonoid N] (f : M →+ N)
(hf : ∀ (x : M), IsAddUnit (f x)) (x : M), ↑((IsAddUnit.liftRight f hf) x) = f x | null | true |
SubmonoidClass.instIsDedekindFiniteMonoidSubtypeMem | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} {A : Type u_3} [inst : MulOneClass M] [inst_1 : SetLike A M] [hA : SubmonoidClass A M] (S : A)
[IsDedekindFiniteMonoid M], IsDedekindFiniteMonoid ↥S | null | true |
Lean.Parser.Command.GrindCnstr.isValue.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | null | true |
map_restrict_ae_le_map_indicator_ae | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
[inst_1 : Zero β],
MeasurableSet s → Filter.map f (MeasureTheory.ae (μ.restrict s)) ≤ Filter.map (s.indicator f) (MeasureTheory.ae μ) | null | true |
Nat.toArray_ric_eq_push | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, 0 < n → (*...=n).toArray = (*...=n - 1).toArray.push n | null | true |
CategoryTheory.kernelUnopUnop_inv | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {A B : Cᵒᵖ}
(g : A ⟶ B),
(CategoryTheory.kernelUnopUnop g).inv =
CategoryTheory.Limits.kernel.lift g.unop (CategoryTheory.Limits.cokernel.π g).unop ⋯ | null | true |
Homotopy.mkCoinductiveAux₁.congr_simp | 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 zero_1 : P.X 1 ⟶ Q.X 0) (e_zero : zero = zero_1)
(one one_1 : P.X 2 ⟶ Q.X 1) (e_one : one = one_1)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp zero (Q.d 0 1)... | null | true |
Interval.inv_bot | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : CommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedMonoid α], ⊥⁻¹ = ⊥ | null | true |
Affine.Simplex.PointsWithCircumcenterIndex._sizeOf_1 | Mathlib.Geometry.Euclidean.Circumcenter | {n : ℕ} → Affine.Simplex.PointsWithCircumcenterIndex n → ℕ | null | false |
GradedAlgHom.ext_iff | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {ι : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grade... | null | true |
Std.Iterators.Types.Append.instProductive | Init.Data.Iterators.Combinators.Monadic.Append | ∀ {α₁ α₂ : Type w} {m : Type w → Type w'} {β : Type w} [inst : Monad m] [inst_1 : Std.Iterator α₁ m β]
[inst_2 : Std.Iterator α₂ m β] [Std.Iterators.Productive α₁ m] [Std.Iterators.Productive α₂ m],
Std.Iterators.Productive (Std.Iterators.Types.Append α₁ α₂ m β) m | null | true |
Mathlib.Tactic.BicategoryLike.AtomIso.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.Expr →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.AtomIso | null | false |
CategoryTheory.Functor.weightedLimObj.preservesLimit | Mathlib.CategoryTheory.Limits.Weighted.PreservesLimit | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{K : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} K] (W : CategoryTheory.Functor J (Type w))
[inst_3 : W.HasWeightedLimObj C] [CategoryTheory.Limits.HasLimitsOfShape K C]
{G : CategoryThe... | null | true |
Polynomial.derivative'._proof_2 | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} [inst : CommSemiring R] (x x_1 : Polynomial R),
Polynomial.derivative (x + x_1) = Polynomial.derivative x + Polynomial.derivative x_1 | null | false |
Set.pi_univ_Ioi_subset | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i) [Nonempty ι],
(Set.univ.pi fun i => Set.Ioi (x i)) ⊆ Set.Ioi x | null | true |
Subgroup.IsComplement.equiv | Mathlib.GroupTheory.Complement | {G : Type u_1} → [inst : Group G] → {S T : Set G} → Subgroup.IsComplement S T → G ≃ ↑S × ↑T | The equivalence `G ≃ S × T`, such that the inverse is `(*) : S × T → G` | true |
CategoryTheory.MorphismProperty.IsMultiplicative.toIsStableUnderComposition | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W : CategoryTheory.MorphismProperty C}
[self : W.IsMultiplicative], W.IsStableUnderComposition | null | true |
StarAlgEquiv.arrowCongr'_trans | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_1} {A₁ : Type u_2} {A₂ : Type u_3} {A₃ : Type u_4} {A₁' : Type u_5} {A₂' : Type u_6} {A₃' : Type u_7}
[inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A₁] [inst_2 : DistribMulAction R A₁] [inst_3 : Star A₁]
[inst_4 : NonUnitalNonAssocSemiring A₂] [inst_5 : DistribMulAction R A₂] [inst_6 : Star A₂... | null | true |
Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertManyIfNewUnit_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α},
l.contains k = false →
Std.DTreeMap.Internal.Impl.contains k ↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯) = true →
Std.DT... | null | true |
ciSup_sup_eq | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {f g : ι → α},
BddAbove (Set.range f) → BddAbove (Set.range g) → ⨆ x, f x ⊔ g x = (⨆ x, f x) ⊔ ⨆ x, g x | null | true |
UInt32.eq_iff_toBitVec_eq | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a = b ↔ a.toBitVec = b.toBitVec | null | true |
CategoryTheory.Bicategory.eqToHomTransIso_refl_right | Mathlib.CategoryTheory.Bicategory.EqToHom | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {x y : B} (e₁ : x = y),
CategoryTheory.Bicategory.eqToHomTransIso e₁ ⋯ =
(CategoryTheory.Bicategory.rightUnitor (CategoryTheory.eqToHom e₁)).symm | null | true |
Matrix.diag_neg | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : Neg α] (A : Matrix n n α), (-A).diag = -A.diag | null | true |
CategoryTheory.DifferentialObject.shiftFunctorAdd_hom_app_f | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_1} [inst : AddCommGroupWithOne S] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (m n : S)
(X : CategoryTheory.DifferentialObject S C),
((CategoryTheory.DifferentialObject.shiftFunctorAdd C m n).hom.... | null | true |
SimpleGraph.edgeSet | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u} → SimpleGraph V → Set (Sym2 V) | `G.edgeSet` is the edge set for `G`.
This is an abbreviation for `edgeSetEmbedding G` that permits dot notation. | true |
HasSubset.noConfusionType | Init.Core | Sort u_1 → {α : Type u} → HasSubset α → {α' : Type u} → HasSubset α' → Sort u_1 | null | false |
Std.Tactic.BVDecide.BVExpr._sizeOf_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {a : ℕ} → Std.Tactic.BVDecide.BVExpr a → ℕ | null | false |
Mathlib.Meta.NormNum.Result'.isNegNNRat.noConfusion | Mathlib.Tactic.NormNum.Result | {P : Sort u} →
{inst : Lean.Expr} →
{q : ℚ} →
{n d proof inst' : Lean.Expr} →
{q' : ℚ} →
{n' d' proof' : Lean.Expr} →
Mathlib.Meta.NormNum.Result'.isNegNNRat inst q n d proof =
Mathlib.Meta.NormNum.Result'.isNegNNRat inst' q' n' d' proof' →
(inst =... | null | false |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.ctorElim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
ctorIdx = t.ctorIdx → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.ctorElimType ctorIdx → motive_7 t | null | false |
_private.Mathlib.Tactic.NormNum.Pow.0.Mathlib.Meta.NormNum.evalPow.match_4 | Mathlib.Tactic.NormNum.Pow | {u : Lean.Level} →
{α : Q(Type u)} →
(e : Q(«$α»)) →
(motive : Option (Mathlib.Meta.NormNum.Result q(«$e»)) → Sort u_1) →
(__x : Option (Mathlib.Meta.NormNum.Result q(«$e»))) →
((r : Mathlib.Meta.NormNum.Result q(«$e»)) → motive (some r)) →
((x : Option (Mathlib.Meta.NormNum.Re... | null | false |
Lean.Parser.initCacheForInput | Lean.Parser.Types | String → Lean.Parser.ParserCache | null | true |
ProbabilityTheory.IsFiniteKernel.isFiniteMeasure | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
[ProbabilityTheory.IsFiniteKernel κ] (a : α), MeasureTheory.IsFiniteMeasure (κ a) | null | true |
_private.Std.Sync.Broadcast.0.Std.Bounded.State.mk.injEq | Std.Sync.Broadcast | ∀ {α : Type} (producers : Std.Queue (IO.Promise Bool)) (waiters : Std.Queue (Std.Broadcast.Consumer✝ α))
(capacity : { x // 0 < x }) (size : ℕ) (buffer : Vector (IO.Ref (Std.Slot✝ α)) ↑capacity) (write read : Fin ↑capacity)
(receivers : Std.TreeMap ℕ ℕ compare) (nextId : ℕ) (closed : Bool) (pos : ℕ)
(producers_1 ... | null | true |
NumberField.Units.complexEmbedding_inj._simp_1 | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ {K : Type u_1} [inst : Field K] (φ : K →+* ℂ) (u v : (NumberField.RingOfIntegers K)ˣ),
((NumberField.Units.complexEmbedding φ) u = (NumberField.Units.complexEmbedding φ) v) = (u = v) | null | false |
CategoryTheory.Functor.leftAdjointObjIsDefined | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor D C → CategoryTheory.ObjectProperty C | Given a functor `F : D ⥤ C`, this is a predicate on objects `X : C` corresponding
to the domain of definition of the (partial) left adjoint of `F`. | true |
Lean.Elab.Tactic.Conv.PatternMatchState.all.noConfusion | Lean.Elab.Tactic.Conv.Pattern | {P : Sort u} →
{subgoals subgoals' : Array Lean.MVarId} →
Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals = Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals' →
(subgoals = subgoals' → P) → P | null | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.initFn.match_1._@.Mathlib.Tactic.Positivity.Core.1480635622._hygCtx._hyg.2 | Mathlib.Tactic.Positivity.Core | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (e : Lean.Expr) → motive (fst, fst_1, e)) → motive x | null | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₃_eq_some_iff_utf8EncodeChar_eq._proof_1_5 | Init.Data.String.Decode | ∀ {c : Char}, (String.utf8EncodeChar c).length = 3 → ¬1 < (String.utf8EncodeChar c).length → False | null | false |
CategoryTheory.Reflective.mk._flat_ctor | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
(∀ {X Y : D}, Function.Surjective R.map) →
autoParam (∀ {X Y : D}, Function.Injective R.map) CategoryTheory.Functor.F... | null | false |
ProbabilityTheory.indep_iSup_directed_limsup | Mathlib.Probability.Independence.ZeroOne | ∀ {Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω}
{β : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : β → Set ι},
(∀ (n : ι), s n ≤ m0) →
ProbabilityTheory.iIndep s μ →
(∀ (t : Set ι), p t → tᶜ ∈ f) →
Directed (fun x1 x2 => x1 ⊆ x... | null | true |
SFinKer.instMonoidalCategory._proof_6 | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X Y₁ Y₂ : SFinKer) (κ : Y₁ ⟶ Y₂), ProbabilityTheory.IsSFiniteKernel (ProbabilityTheory.Kernel.id.parallelComp κ.hom) | null | false |
Prod.instNonAssocRing._proof_1 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (a : R × S), 1 * a = a | null | false |
TopologicalSpace.Opens.leSupr | Mathlib.Topology.Category.TopCat.Opens | {X : TopCat} → {ι : Type u_1} → (U : ι → TopologicalSpace.Opens ↑X) → (i : ι) → U i ⟶ iSup U | The inclusion `U i ⟶ iSup U` as a morphism in the category of open sets.
| true |
Std.ExtHashMap.mem_modify | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α} {f : β → β}, k' ∈ m.modify k f ↔ k' ∈ m | null | true |
BoxIntegral.Prepartition.iUnion_biUnion_partition | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I)
{πi : (J : BoxIntegral.Box ι) → BoxIntegral.Prepartition J},
(∀ J ∈ π, (πi J).IsPartition) → (π.biUnion πi).iUnion = π.iUnion | null | true |
_private.Mathlib.RingTheory.MvPolynomial.Homogeneous.0.MvPolynomial.IsHomogeneous.exists_eval_ne_zero_of_totalDegree_le_card_aux._proof_1_2 | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {n : ℕ} (i a : ℕ), n = i + a + 1 → i + (a + 1) = n | null | false |
AddMonoidAlgebra.toMultiplicativeBialgEquiv._proof_2 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ (R : Type u_3) (A : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A]
[inst_3 : AddMonoid M],
(Algebra.TensorProduct.map ↑(AddMonoidAlgebra.toMultiplicativeAlgEquiv R A M)
↑(AddMonoidAlgebra.toMultiplicativeAlgEquiv R A M)).comp
(Bialgebra.comulAlgHom ... | null | false |
Equiv.mulActionWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.Action.TransferInstance | ∀ (M₀ : Type u_2) {A : Type u_1} {B : Type u_3} (e : A ≃ B) [inst : MonoidWithZero M₀] [inst_1 : Zero B]
[inst_2 : MulActionWithZero M₀ B] (b : A), 1 • b = b | null | false |
Nat.Primes.tprod_eq_tprod_ite | Mathlib.NumberTheory.SumPrimeReciprocals | ∀ {M : Type u_1} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] (f : ℕ → M),
∏' (p : Nat.Primes), f ↑p = ∏' (n : ℕ), if Nat.Prime n then f n else 1 | Reindex a product over `Nat.Primes` as a product over `ℕ`, extending `f` by `1`. | true |
AddSubgroup.toSubgroup._proof_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {A : Type u_1} [inst : AddGroup A] (x : AddSubgroup A),
(fun S =>
let __src := Submonoid.toAddSubmonoid S.toSubmonoid;
{ toAddSubmonoid := __src, neg_mem' := ⋯ })
((fun S =>
let __src := AddSubmonoid.toSubmonoid S.toAddSubmonoid;
{ toSubmonoid := __src, inv_mem' := ⋯ })
... | null | false |
MeasureTheory.Measure.addHaar_preimage_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
r ≠ 0 → ∀ (s : Set E), μ ((fun x => r • x) ⁻¹' s) = ENNReal.ofReal |(r ^ Module.finrank ℝ E)⁻¹| * μ s | null | true |
Mathlib.Tactic.Echelon.DecompositionCert.casesOn | Mathlib.Tactic.Echelon.Cert | {u : Lean.Level} →
{m n : ℕ} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
{A : Q(Matrix (Fin «$m») (Fin «$n») «$α»)} →
{motive : Mathlib.Tactic.Echelon.DecompositionCert rα A → Sort u} →
(t : Mathlib.Tactic.Echelon.DecompositionCert rα A) →
((L : Mathlib.Tactic.E... | null | false |
Lean.Lsp.Command.mk.inj | Lean.Data.Lsp.Basic | ∀ {title command : String} {arguments? : Option (Array Lean.Json)} {title_1 command_1 : String}
{arguments?_1 : Option (Array Lean.Json)},
{ title := title, command := command, arguments? := arguments? } =
{ title := title_1, command := command_1, arguments? := arguments?_1 } →
title = title_1 ∧ command =... | null | true |
Qq.SortLocalDecls.Context._sizeOf_inst | Qq.SortLocalDecls | SizeOf Qq.SortLocalDecls.Context | null | false |
FreeMonoid.equivWithOneFreeSemigroup | Mathlib.Algebra.FreeMonoid.FreeSemigroup | {α : Type u_1} → FreeMonoid α ≃* WithOne (FreeSemigroup α) | The free monoid on `α` is isomorphic to the free semigroup on `α` with a `1` added.
| true |
AlgHom.isIntegrallyClosedIn | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B),
Function.Injective ⇑f → IsIntegrallyClosedIn R B → IsIntegrallyClosedIn R A | Being integrally closed is preserved under injective algebra homomorphisms. | true |
Pi.addHom_apply | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : (i : I) → Add (f i)] {γ : Type w} [inst_1 : Add γ] (g : (i : I) → γ →ₙ+ f i)
(x : γ) (i : I), (AddHom.pi g) x i = (g i) x | **Alias** of `AddHom.pi_apply`. | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.UniqueMul.subsingleton.match_1_1 | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} [inst : Mul G] {A B : Finset G} {a0 b0 : G}
(motive : { ab // ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0 } → Prop)
(x : { ab // ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0 }),
(∀ (_a' _b' : G) (ha' : (_a', _b').1 ∈ A) (hb' : (_a', _b').2 ∈ B) (ab' : (_a', _b').1 * (_a', _b').2 = a0 * b0),
... | null | false |
ContinuousMonoidHom.instCommGroup._proof_3 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ (A : Type u_1) (E : Type u_2) [inst : Monoid A] [inst_1 : TopologicalSpace A] [inst_2 : CommGroup E]
[inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalGroup E] (n : ℕ) (a : A →ₜ* E),
a ^ Int.negSucc n = (ContinuousMonoidHom.inv E).comp (a ^ ↑n.succ) | null | false |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_38 | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_2} {E'' : Type u_3} {F : Type u_4} {H : Type u_5} {G : Type u_6} {E : Type u_1}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F]... | null | false |
preNormEDS_four | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (b c d : R), preNormEDS b c d 4 = d | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp.0.Mathlib.Meta.Positivity.evalSinh._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (α : Q(Type)) (x : Q(Zero «$α»)), «$x» =Q inferInstance | null | false |
Finset.prod_dite_eq' | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (a : ι)
(b : (x : ι) → x = a → M), (∏ x ∈ s, if h : x = a then b x h else 1) = if a ∈ s then b a ⋯ else 1 | null | true |
RootPairing.IsG2.casesOn | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{P : RootPairing ι R M N} →
... | null | false |
_private.Qq.ForLean.Do.0.Lean.Elab.Term.extractBind.extract? | Qq.ForLean.Do | (Lean.Expr → Lean.MetaM (Option Lean.Elab.Term.ExtractMonadResult)) →
Lean.Expr → Lean.MetaM (Option Lean.Elab.Term.ExtractMonadResult) | null | true |
IsCompactOpenCovered | Mathlib.Topology.Sets.CompactOpenCovered | {S : Type u_1} →
{ι : Type u_2} → {X : ι → Type u_3} → ((i : ι) → X i → S) → [(i : ι) → TopologicalSpace (X i)] → Set S → Prop | A set `U` is compact-open covered by the family `fᵢ : X i → S`, if
`U` is the finite union of images of compact open sets in the `X i`. | true |
CategoryTheory.PreOneHypercover.Homotopy.isLimitMultifork._simp_1 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Module.Basis.mk_apply | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : ι → M} (hli : LinearIndependent R v) (hsp : ⊤ ≤ Submodule.span R (Set.range v)) (i : ι),
(Module.Basis.mk hli hsp) i = v i | null | true |
_private.Std.Data.String.ToInt.0.String.Slice.toInt?_eq_some_iff._simp_1_9 | Std.Data.String.ToInt | ∀ (b : Bool), (b = false) = ¬b = true | null | false |
ContinuousLinearMap.isPositive_ofNat | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{n : ℕ} [inst_3 : n.AtLeastTwo], (OfNat.ofNat n).IsPositive | null | true |
String.Slice.Pattern.ForwardSliceSearcher.emptyAt.congr_simp | Init.Data.String.Pattern.String | ∀ {s : String.Slice} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.endPos),
String.Slice.Pattern.ForwardSliceSearcher.emptyAt pos h = String.Slice.Pattern.ForwardSliceSearcher.emptyAt pos_1 ⋯ | null | true |
_private.Mathlib.GroupTheory.Coset.Defs.0.QuotientAddGroup.preimage_image_mk.match_1_7 | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α) (s : Set α) (x : α) (motive : (∃ x_1 ∈ s, -x_1 + x ∈ N) → Prop)
(x_1 : ∃ x_1 ∈ s, -x_1 + x ∈ N), (∀ (y : α) (hs : y ∈ s) (hN : -y + x ∈ N), motive ⋯) → motive x_1 | null | false |
Lean.Elab.Command.checkValidCtorModifier | Lean.Elab.MutualInductive | {m : Type → Type} → [Monad m] → [Lean.MonadError m] → Lean.Elab.Modifiers → m Unit | null | true |
ZMod.inhabited | Mathlib.Data.ZMod.Defs | (n : ℕ) → Inhabited (ZMod n) | null | true |
AlgebraicGeometry.Scheme.Hom.normalizationPullback_snd | Mathlib.AlgebraicGeometry.Normalization | ∀ {X S Y : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f],
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.normalizationPullback f g)
(CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Hom.fr... | null | true |
CategoryTheory.IsMonHom.casesOn | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : C} →
[inst_2 : CategoryTheory.MonObj M] →
[inst_3 : CategoryTheory.MonObj N] →
{f : M ⟶ N} →
{motive : CategoryTheory.IsMonHom f → Sort u} →
... | null | false |
inv_nonpos._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : LinearOrder G₀] {a : G₀} [PosMulMono G₀], (a⁻¹ ≤ 0) = (a ≤ 0) | null | false |
CategoryTheory.IsKernelPair.isIso_of_mono | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X},
CategoryTheory.IsKernelPair f a b → ∀ [CategoryTheory.Mono f], CategoryTheory.IsIso a | null | true |
CategoryTheory.Localization.Monoidal.braidingNatIso._proof_1 | Mathlib.CategoryTheory.Localization.Monoidal.Braided | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [W.IsMonoidal], W.ContainsIdentities | null | false |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.valuation_zpow._simp_1_3 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = -a * b | null | false |
FirstOrder.Language.age.is_equiv_invariant | Mathlib.ModelTheory.Fraisse | ∀ (L : FirstOrder.Language) (M : Type w) [inst : L.Structure M] (N P : CategoryTheory.Bundled L.Structure),
Nonempty (L.Equiv ↑N ↑P) → (N ∈ L.age M ↔ P ∈ L.age M) | null | true |
Vector.getElem_insertIdx_of_gt._proof_6 | Init.Data.Vector.InsertIdx | ∀ {n i k : ℕ}, k ≤ n → k > i → k - 1 < n | null | false |
ConjAct.instDivInvMonoid._aux_8 | Mathlib.GroupTheory.GroupAction.ConjAct | {G : Type u_1} → [DivInvMonoid G] → NPow (ConjAct G) | null | false |
Lean.LLVM.Target.noConfusionType | Lean.Compiler.IR.LLVMBindings | Sort u → {ctx : Lean.LLVM.Context} → Lean.LLVM.Target ctx → {ctx' : Lean.LLVM.Context} → Lean.LLVM.Target ctx' → Sort u | null | false |
Std.Time.TimeZone.Transition._sizeOf_inst | Std.Time.Zoned.ZoneRules | SizeOf Std.Time.TimeZone.Transition | null | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.support_residueClass_prime_div._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] {n : ℕ}, (↑n = 0) = (n = 0) | null | false |
ProofWidgets.Penrose.RpcEncodablePacket._@.ProofWidgets.Component.PenroseDiagram.3621647104._hygCtx._hyg.1 | ProofWidgets.Component.PenroseDiagram | Type | null | false |
Function.Surjective.addActionLeft._proof_2 | Mathlib.Algebra.Group.Action.Hom | ∀ {R : Type u_3} {S : Type u_2} {M : Type u_1} [inst : AddMonoid R] [inst_1 : AddAction R M] [inst_2 : AddMonoid S]
[inst_3 : VAdd S M] (f : R →+ S), (∀ (c : R) (x : M), f c +ᵥ x = c +ᵥ x) → ∀ (b : M), 0 +ᵥ b = b | null | false |
Nat.nth_mem | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (n : ℕ), (∀ (hf : (Set.ofPred p).Finite), n < hf.toFinset.card) → p (Nat.nth p n) | null | true |
partialFunEquivPointed._proof_3 | Mathlib.CategoryTheory.Category.PartialFun | ∀ (X : PartialFun) (a : (partialFunToPointed.comp pointedToPartialFun).obj X), Option.isSome ↑a = true | null | false |
absorbent_ball_zero | Mathlib.Analysis.Normed.Module.Seminorm.Norm | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ}, 0 < r → Absorbent 𝕜 (Metric.ball 0 r) | Balls at the origin are absorbent. | true |
CategoryTheory.Abelian.SpectralObject.opcyclesIsoH_hom | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {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₀ i₁ : ι} (f : i₀ ⟶ i₁) (n₀ n₁ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObje... | null | true |
UInt16.ofBitVec_or | Init.Data.UInt.Bitwise | ∀ (a b : BitVec 16), { toBitVec := a ||| b } = { toBitVec := a } ||| { toBitVec := b } | null | true |
LE.le.sdiff_ssubset_of_nonempty | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → s.Nonempty → t \ s ⊂ t | null | true |
ContinuousMap.instCommCStarAlgebra._proof_6 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_1} {A : Type u_2} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : CommCStarAlgebra A]
(a : C(α, A)), a * 0 = 0 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.