name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Finset.cons.congr_simp | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (a a_1 : α) (e_a : a = a_1) (s s_1 : Finset α) (e_s : s = s_1) (h : a ∉ s),
Finset.cons a s h = Finset.cons a_1 s_1 ⋯ | null | true |
Fintype.card_lt_of_injective_of_notMem | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β),
Function.Injective f → ∀ {b : β}, b ∉ Set.range f → Fintype.card α < Fintype.card β | null | true |
FiniteIndexNormalAddSubgroup.instSemilatticeInfFiniteIndexNormalAddSubgroup._proof_3 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {x y : FiniteIndexNormalAddSubgroup G}, ↑y ⊂ ↑x ↔ ↑y ⊂ ↑x | null | false |
Std.Do.PredTrans.const | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → Std.Do.Assertion ps → Std.Do.PredTrans ps α | The predicate transformer that always returns the same precondition `P`; `(const P).apply Q = P`.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Complex.ofReal_cpow._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {z : ℝ}, (↑z = 0) = (z = 0) | null | false |
Sym.countPerms_coe_fill_of_notMem | Mathlib.Data.Nat.Choose.Multinomial | ∀ {n : ℕ} {α : Type u_1} [inst : DecidableEq α] {m : Fin (n + 1)} {s : Sym α (n - ↑m)} {x : α},
x ∉ s → (↑(Sym.fill x m s)).countPerms = n.choose ↑m * (↑s).countPerms | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.0.IsAddCyclic.of_exponent_eq_card.match_1_1 | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddCommGroup α] (val : Fintype α)
(motive : (∃ a ∈ Finset.univ, addOrderOf a = (Finset.image addOrderOf Finset.univ).max' ⋯) → Prop)
(x : ∃ a ∈ Finset.univ, addOrderOf a = (Finset.image addOrderOf Finset.univ).max' ⋯),
(∀ (g : α) (left : g ∈ Finset.univ) (hg : addOrderOf g = (Finset.image... | null | false |
Int64.shiftLeft_zero | Init.Data.SInt.Bitwise | ∀ {a : Int64}, a <<< 0 = a | null | true |
TopologicalSpace.gciGenerateFrom | Mathlib.Topology.Order | (α : Type u_1) →
GaloisCoinsertion (fun t => OrderDual.toDual {s | IsOpen s}) (TopologicalSpace.generateFrom ∘ ⇑OrderDual.ofDual) | The Galois coinsertion between `TopologicalSpace α` and `(Set (Set α))ᵒᵈ` whose lower part sends
a topology to its collection of open subsets, and whose upper part sends a collection of subsets
of `α` to the topology they generate. | true |
isArtinian_of_finite | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Finite M],
IsArtinian R M | null | true |
Std.TreeSet.instSliceableRocSlice | Std.Data.TreeSet.Slice | {α : Type u} →
(cmp : autoParam (α → α → Ordering) Std.TreeSet.instSliceableRocSlice._auto_1) →
Std.Roc.Sliceable (Std.TreeSet α cmp) α (Std.DTreeMap.Internal.Unit.RocSlice α) | null | true |
Vector.finRange_zero | Init.Data.Vector.FinRange | Vector.finRange 0 = #v[] | null | true |
Lean.Elab.Level.Context.mk | Lean.Elab.Level | Lean.Options → Lean.Syntax → Bool → Lean.Elab.Level.Context | null | true |
_private.Mathlib.Data.Nat.Bitwise.0.Nat.xor_mod_two_eq._simp_1_6 | Mathlib.Data.Nat.Bitwise | ∀ {n : ℕ}, (n % 2 ≠ 0) = (n % 2 = 1) | null | false |
List.pair_mem_product | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : List α} {ys : List β} {x : α} {y : β}, (x, y) ∈ xs.product ys ↔ x ∈ xs ∧ y ∈ ys | List.prod satisfies a specification of cartesian product on lists. | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushInstPending | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Unit | null | true |
_private.Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar.0.BoundedContinuousFunction.mem_charPoly._simp_1_1 | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
{f g : BoundedContinuousFunction α β}, (f = g) = ∀ (x : α), f x = g x | null | false |
NumberField.InfinitePlace.mk_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{v : NumberField.InfinitePlace K} {φ : L →+* ℂ},
φ ∈ NumberField.ComplexEmbedding.mixedEmbeddingsOver L v.embedding →
NumberField.InfinitePlace.mk φ ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm.0.MeasureTheory.average.eq_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
(μ : MeasureTheory.Measure α) (f : α → E), MeasureTheory.average μ f = ∫ (x : α), f x ∂(μ Set.univ)⁻¹ • μ | null | true |
CpltSepUniformSpace.ctorIdx | Mathlib.Topology.Category.UniformSpace | CpltSepUniformSpace → ℕ | null | false |
Nat.Partition.ofSums._proof_1 | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ (l : Multiset ℕ) {i : ℕ}, i ∈ Multiset.filter (fun x => x ≠ 0) l → ⊥ < i | null | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitLet.match_1 | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE binderName type value body nondep)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
VitaliFamily.FineSubfamilyOn.covering.congr_simp | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
{v v_1 : VitaliFamily μ} (e_v : v = v_1) {f f_1 : X → Set (Set X)} (e_f : f = f_1) {s s_1 : Set X} (e_s : s = s_1)
(_h : v.FineSubfamilyOn f s) (a a_1 : X × Set X),
a = a_1 → ∀ (a_2 a_3 : X), a_2 = a_3 → _h.coveri... | null | true |
Std.Roc.lower | Init.Data.Range.Polymorphic.PRange | {α : Type u} → Std.Roc α → α | The lower bound of the range. `lower` is not included in the range.
| true |
NumberField.InfinitePlace.liesOver_embedding_of_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{v : NumberField.InfinitePlace K} {w : NumberField.InfinitePlace L},
w ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v → NumberField.ComplexEmbedding.LiesOver w.embedding v.embedding | null | true |
Std.DTreeMap.toList | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List ((a : α) × β a) | Transforms the tree map into a list of mappings in ascending order. | true |
List.filterMap_flatten | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {L : List (List α)},
List.filterMap f L.flatten = (List.map (List.filterMap f) L).flatten | null | true |
IsLocalDiffeomorph.preimage_boundary | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
CategoryTheory.Abelian.SpectralObject.mono_map | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι) {i₀' i₀ i₁ i₂ i₃ : ι}
(f₁ : i₀ ⟶ i₁) (f₁' : i₀' ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(α : CategoryTheory.... | null | true |
Complex.basisOneI._proof_6 | Mathlib.LinearAlgebra.Complex.Module | NeZero (1 + 1) | null | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Basic.0.Finset.prod_involution._proof_1_3 | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} (s : Finset ι) (g : (a : ι) → a ∈ s → ι),
(∀ (a : ι) (ha : a ∈ s), g a ha ∈ s) → ∀ (x : ι) (hx : x ∈ s) (ha : g x ⋯ ∈ s), g (g x ⋯) ha ∈ s | null | false |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.Stream.next?.match_1.splitter | Batteries.Recycling.RBTree.Lemmas | {α : Type u_1} →
(motive : RBTree.RBNode.Stream α → Sort u_2) →
(x : RBTree.RBNode.Stream α) →
(Unit → motive RBTree.RBNode.Stream.nil) →
((v : α) →
(r : RBTree.RBNode α) → (tail : RBTree.RBNode.Stream α) → motive (RBTree.RBNode.Stream.cons v r tail)) →
motive x | null | true |
QuadraticForm.equivalent_weightedSumSquares_units_of_nondegenerate' | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {K : Type u_3} {V : Type u_8} [inst : Field K] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[FiniteDimensional K V] (Q : QuadraticForm K V),
LinearMap.SeparatingLeft (QuadraticMap.associated Q) →
∃ w, QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares K w) | null | true |
Equiv.Perm.card_cycleType_pos | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α}, 0 < σ.cycleType.card ↔ σ ≠ 1 | null | true |
_private.Lean.Meta.Offset.0.Lean.Meta.isNatZero | Lean.Meta.Offset | Lean.Expr → Lean.MetaM Bool | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.curriedActionMonoidal._proof_21 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_2, u_1} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (x : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
((Catego... | null | false |
Std.CloseableChannel.tryRecv | Std.Sync.Channel | {α : Type} → Std.CloseableChannel α → BaseIO (Option α) | Try to receive a value from the channel, if this can be completed right away without blocking return
`some value`, otherwise return `none`.
| true |
Sigma.instIsTransLex | Mathlib.Order.Sigma.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} [IsTrans ι r]
[∀ (i : ι), IsTrans (α i) (s i)], IsTrans ((i : ι) × α i) (Sigma.Lex r s) | null | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mintro_1 | Std.Tactic.Do.Syntax | Lean.Macro | null | false |
AddMonoidAlgebra.toDirectSum_sub | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_1} {M : Type u_3} [inst : Ring M] (f g : AddMonoidAlgebra M ι),
(f - g).toDirectSum = f.toDirectSum - g.toDirectSum | null | true |
RelLowerSet.rec | Mathlib.Order.Defs.Unbundled | {α : Type u_1} →
[inst : LE α] →
{P : α → Prop} →
{motive : RelLowerSet P → Sort u} →
((carrier : Set α) →
(isRelLowerSet' : IsRelLowerSet carrier P) →
motive { carrier := carrier, isRelLowerSet' := isRelLowerSet' }) →
(t : RelLowerSet P) → motive t | null | false |
ContinuousMapZero.mk.congr_simp | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : Zero R] [inst_2 : TopologicalSpace X]
[inst_3 : TopologicalSpace R] (toContinuousMap toContinuousMap_1 : C(X, R))
(e_toContinuousMap : toContinuousMap = toContinuousMap_1) (map_zero' : toContinuousMap 0 = 0),
{ toContinuousMap := toContinuousMap, map_zero'... | null | true |
_private.Mathlib.Topology.LocalAtTarget.0.TopologicalSpace.IsOpenCover.isHomeomorph_iff_restrictPreimage._simp_1_1 | Mathlib.Topology.LocalAtTarget | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsHomeomorph f = (Topology.IsEmbedding f ∧ Function.Surjective f) | null | false |
_private.ImportGraph.WorkspaceModel.Build.0.ImportGraph.Lake.WorkspaceSummary.toWorkspaceModel.match_1 | ImportGraph.WorkspaceModel.Build | (motive : Option (ℕ × Std.Iter ℕ) → Sort u_1) →
(x : Option (ℕ × Std.Iter ℕ)) →
(Unit → motive none) → ((libIdx : ℕ) → (s' : Std.Iter ℕ) → motive (some (libIdx, s'))) → motive x | null | false |
_private.Mathlib.MeasureTheory.Covering.LiminfLimsup.0.blimsup_cthickening_mul_ae_eq._simp_1_1 | Mathlib.MeasureTheory.Covering.LiminfLimsup | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | null | false |
_private.Mathlib.Data.Finset.Empty.0.Finset.notMem_empty._simp_1_2 | Mathlib.Data.Finset.Empty | ∀ {α : Type u_1} (a : α), (a ∈ 0) = False | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.WithDensityVec.0.MeasureTheory.VectorMeasure.variation_withDensity'._simp_1_14 | Mathlib.MeasureTheory.VectorMeasure.WithDensityVec | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {b : β},
(b ∈ f.range) = (b ∈ Set.range ⇑f) | null | false |
AlgebraNorm.mk._flat_ctor | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
(toFun : S → ℝ) →
toFun 0 = 0 →
(∀ (r s : S), toFun (r + s) ≤ toFun r + toFun s) →
(∀ (r : S), toFun (-r) = toFun r) →
... | null | false |
Lean.LocalDecl.ctorElim | Lean.LocalContext | {motive : Lean.LocalDecl → Sort u} →
(ctorIdx : ℕ) → (t : Lean.LocalDecl) → ctorIdx = t.ctorIdx → Lean.LocalDecl.ctorElimType ctorIdx → motive t | null | false |
Lean.Plugin.instFromJson | Lean.Setup | Lean.FromJson Lean.Plugin | null | true |
inf_eq_and_sup_eq_iff | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b c : α}, a ⊓ b = c ∧ a ⊔ b = c ↔ a = c ∧ b = c | null | true |
Lean.Parser.Term.strictImplicitRightBracket.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
Affine.Triangle.toPolygon_toTriangle | Mathlib.Geometry.Polygon.Basic | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] (t : Affine.Triangle R P), Polygon.toTriangle R (Affine.Triangle.toPolygon t) ⋯ = t | Converting a triangle to a polygon and back yields the original triangle. | true |
Function.range_eq_image_or_of_mulSupport_subset | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {k : Set ι},
Function.mulSupport f ⊆ k → Set.range f = f '' k ∨ Set.range f = insert 1 (f '' k) | null | true |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory._aux_Mathlib_MeasureTheory_Group_FundamentalDomain___unexpand_AddAction_orbitRel_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | Lean.PrettyPrinter.Unexpander | null | false |
DomAddAct.instFaithfulVAddForallOfNontrivial | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {β : Type u_2} {α : Type u_3} [inst : VAdd M α] [FaithfulVAdd M α] [Nontrivial β],
FaithfulVAdd Mᵈᵃᵃ (α → β) | null | true |
_private.Mathlib.Topology.Homotopy.Basic.0.ContinuousMap.Homotopic.prodMk.match_1_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(X, Z)} (motive : f₀.Homotopic f₁ → g₀.Homotopic g₁ → Prop)
(x : f₀.Homotopic f₁) (x_1 : g₀.Homotopic g₁),
(∀ (F : f₀.Homotopy f₁) (G : g₀.Homotopy g₁)... | null | false |
CategoryTheory.StrictPseudofunctorCore.map₂_right_unitor._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | Lean.Syntax | null | false |
Mathlib.Meta.NormNum.findNotPowerCertificate | Mathlib.Tactic.NormNum.Irrational | (m n : Q(ℕ)) → Lean.MetaM (Mathlib.Meta.NormNum.NotPowerCertificate m n) | Finds `NotPowerCertificate` showing that `m` is not `n`-power. | true |
Symmetric.flip_eq | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Symm r], flip r = r | **Alias** of `Std.Symm.flip_eq`. | true |
affineHomeomorph._proof_1 | Mathlib.Topology.Algebra.Field | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (a b : 𝕜), a ≠ 0 → ∀ (x : 𝕜), (fun y => (y - b) / a) ((fun x => a * x + b) x) = x | null | false |
Nat.ofDigits_eq_sum_mapIdx | Mathlib.Data.Nat.Digits.Lemmas | ∀ (b : ℕ) (L : List ℕ), Nat.ofDigits b L = (List.mapIdx (fun i a => a * b ^ i) L).sum | null | true |
HomRel.FactorsThroughLocalization.strictUniversalPropertyFixedTarget._proof_5 | Mathlib.CategoryTheory.Localization.Quotient | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {homRel : HomRel C}
{W : CategoryTheory.MorphismProperty C},
homRel.FactorsThroughLocalization W →
∀ {E : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} E] (F : CategoryTheory.Functor C E),
W.IsInvertedBy F → ∀ (x x_1 : C) (f g : x ⟶ x... | null | false |
AddSubgroup.index_eq_zero_iff_infinite | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.index = 0 ↔ Infinite (G ⧸ H) | null | true |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.degree_add_le._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {m : σ →₀ ℕ},
(m ∉ p.support) = (p.coeff m = 0) | null | false |
TopologicalSpace.Compacts.coe_toCloseds | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : T2Space α] (s : TopologicalSpace.Compacts α), ↑s.toCloseds = ↑s | null | true |
_private.Mathlib.CategoryTheory.Quotient.Preadditive.0.CategoryTheory.Quotient.Preadditive.add._simp_1 | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (r : HomRel C)
[CategoryTheory.HomRel.IsStableUnderPrecomp r] [CategoryTheory.HomRel.IsStableUnderPostcomp r] {X Y : C}
(f g : X ⟶ Y), CategoryTheory.HomRel.CompClosure r f g = r f g | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.FirstPage.0.CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.HasFirstPageComputation._proof_1 | Mathlib.Algebra.Homology.SpectralObject.FirstPage | ∀ {r₀ : ℤ}, r₀ ≤ r₀ | null | false |
ULift.addLeftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : AddLeftCancelSemigroup α],
ULift.addLeftCancelSemigroup = Function.Injective.addLeftCancelSemigroup ⇑Equiv.ulift ⋯ ⋯ | null | true |
ModuleCat.MonModuleEquivalenceAlgebra.Algebra_of_Mon_._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : ModuleCat R) [inst_1 : CategoryTheory.MonObj A]
(x y : ↑(CategoryTheory.MonoidalCategoryStruct.tensorUnit (ModuleCat R))),
(ModuleCat.Hom.hom CategoryTheory.MonObj.one).toFun (x + y) =
(ModuleCat.Hom.hom CategoryTheory.MonObj.one).toFun x + (ModuleCat.Hom.hom CategoryTh... | null | false |
String.Slice.Pattern.Model.matchAt?_eq_none_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {startPos : s.Pos},
String.Slice.Pattern.Model.matchAt? pat startPos = none ↔ ¬String.Slice.Pattern.Model.MatchesAt pat startPos | null | true |
SeparatelyContinuousMul.continuous_mul_const | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} {inst : TopologicalSpace M} {inst_1 : Mul M} [self : SeparatelyContinuousMul M] {a : M},
Continuous fun x => x * a | null | true |
List.reverse_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a : α}, (List.replicate n a).reverse = List.replicate n a | null | true |
CategoryTheory.Monad.monadMonEquiv._proof_28 | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C],
CategoryTheory.CategoryStruct.comp
{
app := fun x =>
{
hom :=
CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id (CategoryTheory.Mon (CategoryTheory.Functor C C))).obj x).X,
... | null | false |
ConditionallyCompleteLinearOrder.compare_eq_compareOfLessAndEq | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ {α : Type u_2} [self : ConditionallyCompleteLinearOrder α] (a b : α), compare a b = compareOfLessAndEq a b | Comparison via `compare` is equal to the canonical comparison given decidable `<` and `=`. | true |
ProperSpace.of_isCompact_closedBall_of_le | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α] (R : ℝ),
(∀ (x : α) (r : ℝ), R ≤ r → IsCompact (Metric.closedBall x r)) → ProperSpace α | If all closed balls of large enough radius are compact, then the space is proper. Especially
useful when the lower bound for the radius is 0. | true |
ContinuousLinearMapWOT._aux_Mathlib_Analysis_LocallyConvex_WeakOperatorTopology___unexpand_ContinuousLinearMapWOT_2 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | Lean.PrettyPrinter.Unexpander | null | false |
SimpleGraph.Walk.lastDart_mem_darts._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w} (hnil : ¬p.Nil), (p.lastDart hnil ∈ p.darts) = True | null | false |
Locale.PT.instTopologicalSpace._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ (L : Type u_1) [inst : CompleteLattice L] (S : Set (Set (Locale.PT L))),
(∀ t ∈ S, ∃ u, {x | x u} = t) → ∃ u, {x | x u} = ⋃₀ S | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_eq_ediv._simp_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ (n : ℕ), (0 ≤ Int.negSucc n) = False | null | false |
Submodule.starProjection_singleton | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{v : E} (w : E), (𝕜 ∙ v).starProjection w = (inner 𝕜 v w / ↑(‖v‖ ^ 2)) • v | Formula for orthogonal projection onto a single vector. | true |
Finset.measurable_range_sup' | Mathlib.MeasureTheory.Order.Lattice | ∀ {α : Type u_2} {m : MeasurableSpace α} {δ : Type u_3} [inst : MeasurableSpace δ] [inst_1 : SemilatticeSup α]
[MeasurableSup₂ α] {f : ℕ → δ → α} {n : ℕ}, (∀ k ≤ n, Measurable (f k)) → Measurable ((Finset.range (n + 1)).sup' ⋯ f) | null | true |
AddSubgroup.coe_add_of_left_le_normalizer_right | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (H N : AddSubgroup G), H ≤ AddSubgroup.normalizer ↑N → ↑(H ⊔ N) = ↑H + ↑N | The carrier of `H ⊔ N` is just `↑H + ↑N` (pointwise set addition)
when `H` is a subgroup of the normalizer of `N` in `G`. | true |
ContinuousMapZero.instStarRing._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_2} {R : Type u_1} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : StarRing R] [inst_5 : ContinuousStar R] (x : ContinuousMapZero X R),
(star ↑{ toContinuousMap := star ↑x, map_zero' := ⋯ }) 0 = 0 | null | false |
Mathlib.Tactic.BicategoryLike.AtomIso.recOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.AtomIso → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.AtomIso) →
((e : Lean.Expr) → (src tgt : Mathlib.Tactic.BicategoryLike.Mor₁) → motive { e := e, src := src, tgt := tgt }) →
motive t | null | false |
MeasureTheory.Integrable.integral_norm_condDistrib_map | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpa... | null | true |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.objSuccIso | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : Type u} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
{j : J} →
¬IsMax j →
(F : CategoryTheory.Functor (↑(Set.Iic j)) C) →
(X : C) → CategoryTheory.SmallObject.SuccStruct... | The isomorphism `obj F X ⟨Order.succ j, _⟩ ≅ X`. | true |
SchwartzMap.smulLeftCLM.eq_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} (F : Type u_6) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NontriviallyNormedField 𝕜]
[inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedSpace 𝕜 F] (g : E → 𝕜),
SchwartzMap.smulLeftCLM F g =
if hg ... | null | true |
Nat.Partrec.Code.primrec_pappAck | Mathlib.Computability.Ackermann | Primrec Nat.Partrec.Code.pappAck | null | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.y | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} → {hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution✝ hζ → NumberField.RingOfIntegers K | Given `S : Solution`, we let `S.y` be any element such that `S.a + η * S.b = λ * S.y` | true |
ContMDiff.piecewise_Iic | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {n : WithTop ℕ∞} {E : Type u_11} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_12}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type u_13} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] {f g : ℝ → M} {s : ℝ},
ContMDiff (modelWithCornersSelf ℝ ℝ) I n f →
C... | Given two `C^n` functions `f` and `g` from `ℝ` to a real manifold which coincide locally
around a point `s`, then the piecewise function using `f` before `t` and `g` after is `C^n`. | true |
CategoryTheory.Adjunction.functorialityCounit._proof_2 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] (K : CategoryTheory.Functor J C)
(c : Categor... | null | false |
Submodule.map_comap_subtype | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p p' : Submodule R M), Submodule.map p.subtype (Submodule.comap p.subtype p') = p ⊓ p' | null | true |
LinearPMap.adjointDomainMkCLMExtend._proof_6 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], ContinuousConstSMul 𝕜 𝕜 | null | false |
CategoryTheory.FreeBicategory.Hom₂ | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} → [inst : Quiver B] → {a b : CategoryTheory.FreeBicategory B} → (a ⟶ b) → (a ⟶ b) → Type (max u v) | Representatives of 2-morphisms in the free bicategory. | true |
instIsLeftAdjointSSetTopCatToTop | Mathlib.AlgebraicTopology.SingularSet | SSet.toTop.IsLeftAdjoint | null | true |
RegularExpression.char.elim | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} →
(t : RegularExpression α) → t.ctorIdx = 2 → ((a : α) → motive (RegularExpression.char a)) → motive t | null | false |
_private.Mathlib.Data.List.PeriodicityLemma.0.List.HasPeriod.factor._proof_1_6 | Mathlib.Data.List.PeriodicityLemma | ∀ {α : Type u_1} {u : List α} {p : ℕ} (j : ℕ), u.length ≤ j + u.length + p | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.inclusion.congr_simp | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J),
AlgebraicGeometry.Scheme.IdealSheafData.inclusion h = AlgebraicGeometry.Scheme.IdealSheafData.inclusion h | null | true |
Std.Sat.AIG.IsPrefix_push._simp_1 | Std.Sat.AIG.LawfulOperator | ∀ {α : Type} {decl : Std.Sat.AIG.Decl α} {decls : Array (Std.Sat.AIG.Decl α)},
Std.Sat.AIG.IsPrefix decls (decls.push decl) = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.