name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.Sym.SharedExprs.ctorIdx | Lean.Meta.Sym.SymM | Lean.Meta.Sym.SharedExprs → ℕ | false |
Lean.Parser.ParserAttributeHook.rec | Lean.Parser.Extension | {motive : Lean.Parser.ParserAttributeHook → Sort u} →
((postAdd : Lean.Name → Lean.Name → Bool → Lean.AttrM Unit) → motive { postAdd := postAdd }) →
(t : Lean.Parser.ParserAttributeHook) → motive t | false |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat_i₃ | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (pq : ℕ × ℕ) (hr : 2 ≤ r),
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat.i₃ r pq hr = WithBotTop.coe (-↑pq.2 + r - 1) | true |
Prod.snd | Init.Prelude | {α : Type u} → {β : Type v} → α × β → β | true |
Std.Do.Spec.forIn'_roc | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps]
[inst_2 : LE α] [inst_3 : DecidableLE α] [inst_4 : LT α] [inst_5 : Std.PRange.UpwardEnumerable α]
[inst_6 : Std.Rxc.IsAlwaysFinite α] [inst_7 : Std.PRange.LawfulUpwardEnumerable α]
[inst_8 : Std.PRange.L... | true |
instTrivialStarNNReal | Mathlib.Data.NNReal.Star | TrivialStar NNReal | true |
IsLocallyConstant.one | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : One Y], IsLocallyConstant 1 | true |
List.Vector.tail.match_1 | Mathlib.Data.Vector.Defs | {α : Type u_1} →
{n : ℕ} →
(motive : List.Vector α n → Sort u_2) →
(x : List.Vector α n) →
((h : [].length = n) → motive ⟨[], h⟩) →
((head : α) → (v : List α) → (h : (head :: v).length = n) → motive ⟨head :: v, h⟩) → motive x | false |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.map_on.match_1_1 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l : List α} (a b : α) (motive : a ∈ l ∧ b ∈ l ∧ a ≠ b → Prop) (x : a ∈ l ∧ b ∈ l ∧ a ≠ b),
(∀ (ma : a ∈ l) (mb : b ∈ l) (n : a ≠ b), motive ⋯) → motive x | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift.0.Std.IterM.length_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3)
(h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
... | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.congrHash.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((x : Lean.Expr) → motive x) → motive e | false |
AddChar.add_apply | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : CommMonoid M] (ψ φ : AddChar A M) (a : A),
(ψ + φ) a = ψ a * φ a | true |
Matrix.toBlocks₁₂.eq_1 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} (M : Matrix (n ⊕ o) (l ⊕ m) α),
M.toBlocks₁₂ = Matrix.of fun i j => M (Sum.inl i) (Sum.inr j) | true |
CommGrpCat.mk.noConfusion | Mathlib.Algebra.Category.Grp.Basic | {P : Sort u_1} →
{carrier : Type u} →
{str : CommGroup carrier} →
{carrier' : Type u} →
{str' : CommGroup carrier'} →
{ carrier := carrier, str := str } = { carrier := carrier', str := str' } →
(carrier = carrier' → str ≍ str' → P) → P | false |
Matrix.blockDiagonal_transpose | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} [inst : DecidableEq o] [inst_1 : Zero α]
(M : o → Matrix m n α), (Matrix.blockDiagonal M).transpose = Matrix.blockDiagonal fun k => (M k).transpose | true |
AddSubgroup.leftCosetEquivAddSubgroup._proof_2 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (g : α) (x : ↥s), ∃ a ∈ ↑s, g +ᵥ a = g + ↑x | false |
_private.Mathlib.Topology.Order.0.IndiscreteTopology.isClosed_iff._simp_1_1 | Mathlib.Topology.Order | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | false |
CategoryTheory.TransfiniteCompositionOfShape.map._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {J : Type u_5} [inst_2 : LinearOrder J] [inst_3 : OrderBot J]
{X Y : C} {f : X ⟶ Y} [inst_4 : SuccOrder J] [inst_5 : WellFoundedLT J]
(c : CategoryTheory.TransfiniteCompositionOfShape J f)... | false |
_private.Mathlib.Tactic.Linter.UnusedInstancesInType.0.Mathlib.Linter.UnusedInstancesInType.InstanceOfConcern.idx | Mathlib.Tactic.Linter.UnusedInstancesInType | Mathlib.Linter.UnusedInstancesInType.InstanceOfConcern✝ → ℕ | true |
SimpleGraph.ConnectedComponent.ind | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {β : G.ConnectedComponent → Prop},
(∀ (v : V), β (G.connectedComponentMk v)) → ∀ (c : G.ConnectedComponent), β c | true |
CategoryTheory.hasLeftDualUnit | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.HasLeftDual (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | true |
AlgebraicGeometry.Proj.openCoverOfMapIrrelevantEqTop | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | {σ : Type u_1} →
{A : Type u} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
{X : AlgebraicGeometry.Scheme} →
(f : A →+* ↑(X.presheaf.obj (Opposite.op ⊤))) →
... | true |
sSupHom.comp._proof_1 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} [inst : SupSet α] [inst_1 : SupSet β] [inst_2 : SupSet γ]
(f : sSupHom β γ) (g : sSupHom α β) (s : Set α), (⇑f ∘ ⇑g) (sSup s) = sSup (⇑f ∘ ⇑g '' s) | false |
Set.self_mem_ordConnectedComponent._simp_1 | Mathlib.Order.Interval.Set.OrdConnectedComponent | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {x : α}, (x ∈ s.ordConnectedComponent x) = (x ∈ s) | false |
_private.Lean.Parser.Basic.0.Lean.Parser.longestMatchFnAux.parse._sunfold | Lean.Parser.Basic | Option Lean.Syntax → ℕ → ℕ → String.Pos.Raw → ℕ → List (Lean.Parser.Parser × ℕ) → Lean.Parser.ParserFn | false |
CategoryTheory.Cat.isTerminalOfUniqueOfIsDiscrete._proof_1 | Mathlib.CategoryTheory.Category.Cat.Terminal | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] [inst_1 : Unique T] [CategoryTheory.IsDiscrete T]
(x : CategoryTheory.Cat) (x_1 : x ⟶ CategoryTheory.Cat.of T),
x_1 = ((CategoryTheory.Functor.const ↑x).obj default).toCatHom | false |
Batteries.HashMap.insert | Batteries.Data.HashMap.Basic | {α : Type u_1} →
{x : BEq α} → {x_1 : Hashable α} → {β : Type u_2} → Batteries.HashMap α β → α → β → Batteries.HashMap α β | true |
_private.Mathlib.RingTheory.TensorProduct.DirectLimitFG.0.TensorProduct.exists_of_fg.match_1_1 | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ {R : Type u_2} {M : Type u_1} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (u : TensorProduct R M N)
(motive :
(∃ i x,
(Module.DirectLimit.of R { P // P.FG } (fun P => TensorProduct R (↥↑P) N)
(fu... | false |
Module.IsPrincipal.of_surjective | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M₂] (f : M →ₗ[R] M₂),
Function.Surjective ⇑f → ∀ [Module.IsPrincipal R M], Module.IsPrincipal R M₂ | true |
uniformity_multiplicative | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α],
uniformity (Multiplicative α) = Filter.map (Prod.map ⇑Multiplicative.ofAdd ⇑Multiplicative.ofAdd) (uniformity α) | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trStmts₁.match_1.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (motive : Turing.PartrecToTM2.Λ' → Sort u_1) (k : Turing.PartrecToTM2.K')
(s : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ') (q : Turing.PartrecToTM2.Λ')
(h_1 :
(Q : Turing.PartrecToTM2.Λ') →
(p : Turing.PartrecToTM2.Γ' → Bool) →
(k₁ k₂ : Turing.PartrecToTM2.K') →
(q :... | true |
AddSemiconjBy.neg_neg_symm | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a x y : G}, AddSemiconjBy a y x → AddSemiconjBy (-a) (-x) (-y) | true |
Homeomorph.neg.eq_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [inst_2 : ContinuousNeg G],
Homeomorph.neg G = { toEquiv := Equiv.neg G, continuous_toFun := ⋯, continuous_invFun := ⋯ } | true |
CategoryTheory.InducedCategory.homEquiv | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → (X ⟶ Y) ≃ (F X ⟶ F Y) | true |
_private.Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic.0.quadraticChar_card_sqrts._simp_1_1 | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀], (a ^ 2 = 0) = (a = 0) | false |
_private.Mathlib.AlgebraicTopology.DoldKan.NCompGamma.0.AlgebraicTopology.DoldKan.PInfty_comp_map_mono_eq_zero._proof_1_7 | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | ∀ (m k : ℕ) (i : SimplexCategory.mk m ⟶ SimplexCategory.mk (m + k + 1 + 1)), CategoryTheory.Epi i → False | false |
Units.mul_le_of_le_mul_inv | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulRightMono M] {a b : M} (u : Mˣ), a ≤ b * ↑u⁻¹ → a * ↑u ≤ b | true |
SelbergSieve.level | Mathlib.NumberTheory.SelbergSieve | SelbergSieve → ℝ | true |
Lean.Meta.Grind.CasesTypes.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | ∀ (casesMap : Lean.PHashMap Lean.Name Bool), sizeOf { casesMap := casesMap } = 1 + sizeOf casesMap | true |
_private.Mathlib.Analysis.BoxIntegral.UnitPartition.0.BoxIntegral.unitPartition.tendsto_card_div_pow₄ | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (s : Set (ι → ℝ)) [inst : Fintype ι],
Bornology.IsBounded s →
(∀ ⦃x y : ℝ⦄, 0 < x → x ≤ y → x • s ⊆ y • s) →
∀ᶠ (x : ℝ) in Filter.atTop,
↑(Nat.card ↑(s ∩ x⁻¹ • ↑(Submodule.span ℤ (Set.range ⇑(Pi.basisFun ℝ ι))))) / x ^ Fintype.card ι ≤
↑(Nat.card ↑(s ∩ (↑⌈x⌉₊)⁻¹ • ↑(Submod... | true |
Equiv.Perm.support_swap_mul_swap | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {x y z : α},
[x, y, z].Nodup → (Equiv.swap x y * Equiv.swap y z).support = {x, y, z} | true |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.visitForall._sparseCasesOn_5 | Lean.Compiler.LCNF.Types | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
_private.Init.Data.Nat.Lemmas.0.Nat.pow_lt_pow_iff_left._simp_1_1 | Init.Data.Nat.Lemmas | ∀ {a b : ℕ}, (b < a) = ¬a ≤ b | false |
AnalyticWithinAt.im_ofReal | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | ∀ {f : ℂ → ℂ} {s : Set ℝ} {x : ℝ},
AnalyticWithinAt ℂ f (Complex.ofReal '' s) ↑x → AnalyticWithinAt ℝ (fun x => (f ↑x).im) s x | true |
SimpleGraph.Iso.connectedComponentEquiv_symm | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G ≃g G'),
φ.symm.connectedComponentEquiv = φ.connectedComponentEquiv.symm | true |
Lean.Doc.Data.inst._@.Lean.Elab.DocString.Builtin.3070054517._hygCtx._hyg.15 | Lean.Elab.DocString.Builtin | TypeName Lean.Doc.Data.SetOption | false |
InnerProductSpace.gramSchmidtNormed_orthonormal' | Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι] [inst_5 : WellFoundedLT ι] (f : ι → E),
Orthonormal 𝕜 fun i => InnerProductSpace.gramSchmidtNormed 𝕜 f ↑i | true |
Quaternion.instRing._proof_22 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] (a : Quaternion R), 1 * a = a | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Quasispectrum.0.quasispectrum.algebraMap_mem_iff._simp_1_1 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (S : Type u_1) {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A] {a : A} {r : R},
((algebraMap R S) r ∈ spectrum S a) = (r ∈ spectrum R a) | false |
Std.TreeMap.ofList | Std.Data.TreeMap.Basic | {α : Type u} →
{β : Type v} → List (α × β) → (cmp : autoParam (α → α → Ordering) Std.TreeMap.ofList._auto_1) → Std.TreeMap α β cmp | true |
Mathlib.Meta.NormNum.NormNums.mk.sizeOf_spec | Mathlib.Tactic.NormNum.Core | ∀ (tree : Lean.Meta.DiscrTree Mathlib.Meta.NormNum.NormNumExt) (erased : Lean.PHashSet Lean.Name),
sizeOf { tree := tree, erased := erased } = 1 + sizeOf tree + sizeOf erased | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.Equiv.Perm.count_le_one_of_centralizer_le_alternating._simp_1_3 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_2} [inst : Add α] [inst_1 : Mul α] {a : α} [LeftDistribClass α], Even a → ∀ (b : α), Even (b * a) = True | false |
Array.findSomeM?._sparseCasesOn_1.else_eq | Init.Data.List.ToArray | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Array.findSomeM?._sparseCasesOn_1 t some «else» = «else» h | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.lt_length_drop._simp_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {k n m : ℕ}, (k + n < k + m) = (n < m) | false |
Nat.lcm_lcm_self_right_right | Init.Data.Nat.Lcm | ∀ (m n : ℕ), m.lcm (n.lcm m) = m.lcm n | true |
AddMonoidHom.continuous_of_isBounded_nhds_zero | Mathlib.Analysis.Normed.Module.Basic | ∀ {G : Type u_6} {H : Type u_7} [inst : SeminormedAddCommGroup G] [inst_1 : SeminormedAddCommGroup H] [NormedSpace ℝ H]
{s : Set G} (f : G →+ H), s ∈ nhds 0 → Bornology.IsBounded (⇑f '' s) → Continuous ⇑f | true |
Std.DTreeMap.Const.isEmpty_insertMany_list | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{l : List (α × β)}, (Std.DTreeMap.Const.insertMany t l).isEmpty = (t.isEmpty && l.isEmpty) | true |
PartialEquiv.refl_prod_refl | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2}, (PartialEquiv.refl α).prod (PartialEquiv.refl β) = PartialEquiv.refl (α × β) | true |
prod_mk_prod | Mathlib.Algebra.BigOperators.Pi | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : CommMonoid M] [inst_1 : CommMonoid N] (s : Finset ι) (f : ι → M)
(g : ι → N), (∏ x ∈ s, f x, ∏ x ∈ s, g x) = ∏ x ∈ s, (f x, g x) | true |
CategoryTheory.MorphismProperty.IsStableUnderFiniteCoproducts.rec | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{motive : W.IsStableUnderFiniteCoproducts → Sort u_1} →
((isStableUnderCoproductsOfShape : ∀ (J : Type) [Finite J], W.IsStableUnderCoproductsOfShape J) → motive ⋯) →
(t : W.IsStableUnderFin... | false |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.derivedSeries_le_lowerCentralSeries._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | false |
FiniteGaloisIntermediateField.instMax._proof_3 | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L₁ L₂ : FiniteGaloisIntermediateField k K), IsGalois k ↥(L₁.toIntermediateField ⊔ L₂.toIntermediateField) | false |
Int16.le_antisymm | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, a ≤ b → b ≤ a → a = b | true |
Batteries.RBNode.EMem.eq_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} (x : α) (t : Batteries.RBNode α),
Batteries.RBNode.EMem x t = Batteries.RBNode.Any (fun x_1 => x = x_1) t | true |
ProfiniteAddGrp.Hom.ext | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {x y : A.Hom B}, x.hom' = y.hom' → x = y | true |
_private.Mathlib.Data.Stream.Init.0.Stream'.even_interleave.match_1_1 | Mathlib.Data.Stream.Init | ∀ {α : Type u_1} (s₁' s₁ : Stream' α) (motive : (∃ s₂, s₁' = (s₁ ⋈ s₂).even) → Prop) (x : ∃ s₂, s₁' = (s₁ ⋈ s₂).even),
(∀ (s₂ : Stream' α) (h₁ : s₁' = (s₁ ⋈ s₂).even), motive ⋯) → motive x | false |
_private.Mathlib.NumberTheory.ModularForms.Delta.0.ModularForm.logDeriv_eta_comp_eq_logDeriv_csqrt_eta._simp_1_4 | Mathlib.NumberTheory.ModularForms.Delta | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
CategoryTheory.OverPresheafAux.OverArrows.map₂.congr_simp | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A}
{X Y : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {t : CategoryTheory.yoneda.obj Y ⟶ A}
(u u_1 : CategoryTheory.OverPresheafAux.OverArrows η t),
u = u_1 →
∀ (f f_1 : X ⟶ Y) (e_f : f = f_1) (hst : Cat... | true |
Types.subobjectEquivSet | Mathlib.CategoryTheory.Subobject.Types | (α : Type u) → CategoryTheory.Subobject α ≃o Set α | true |
WithBot.instCommSemiring._proof_13 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α]
[inst_3 : CanonicallyOrderedAdd α] [inst_4 : NoZeroDivisors α] [inst_5 : Nontrivial α],
autoParam
(∀ (n : ℕ) (x : WithBot α), WithBot.instCommSemiring._aux_10 (n + 1) x = WithBot.instCommSemiring._aux_10 n x * x)
Mon... | false |
Algebra.basicOpen_subset_etaleLocus_iff_etale | Mathlib.RingTheory.Etale.Locus | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[Algebra.FinitePresentation R A] {f : A},
↑(PrimeSpectrum.basicOpen f) ⊆ Algebra.etaleLocus R A ↔ Algebra.Etale R (Localization.Away f) | true |
groupHomology.cyclesMap_comp_cyclesIso₀_hom_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (x : ↑(groupHomology.cycles A 0)),
(CategoryTheory.ConcreteCategory.hom (groupHomology.cyclesIso₀ B).hom)
((CategoryTheory.ConcreteCategory.hom (group... | true |
TopCat.pullbackIsoProdSubtype | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | {X Y Z : TopCat} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
CategoryTheory.Limits.pullback f g ≅
TopCat.of { p // (CategoryTheory.ConcreteCategory.hom f) p.1 = (CategoryTheory.ConcreteCategory.hom g) p.2 } | true |
Finset.range_val | Mathlib.Data.Finset.Range | ∀ (n : ℕ), (Finset.range n).val = Multiset.range n | true |
SaturatedAddSubmonoid.rec | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} →
[inst : AddZeroClass M] →
{motive : SaturatedAddSubmonoid M → Sort u} →
((toAddSubmonoid : AddSubmonoid M) →
(addSaturated : toAddSubmonoid.AddSaturated) →
motive { toAddSubmonoid := toAddSubmonoid, addSaturated := addSaturated }) →
(t : SaturatedAddSubmonoid M... | false |
IsLeftCancelVAdd.mk | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} [inst : VAdd G P],
(∀ (a : G) (b c : P), a +ᵥ b = a +ᵥ c → b = c) → IsLeftCancelVAdd G P | true |
AlgebraicIndependent.transcendental_adjoin_iff | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {ι : Type u_1} {R : Type u_3} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A],
AlgebraicIndependent R x →
∀ [Nontrivial A] {s : Set ι} {i : ι}, Transcendental (↥(Algebra.adjoin R (x '' s))) (x i) ↔ i ∉ s | true |
instLocallyConvexSpaceRealOfPolynormableSpace | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {E : Type u_6} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [PolynormableSpace ℝ E],
LocallyConvexSpace ℝ E | true |
Turing.PartrecToTM2.contSupp.match_1 | Mathlib.Computability.TuringMachine.ToPartrec | (motive : Turing.PartrecToTM2.Cont' → Sort u_1) →
(x : Turing.PartrecToTM2.Cont') →
((fs : Turing.ToPartrec.Code) → (k : Turing.PartrecToTM2.Cont') → motive (Turing.PartrecToTM2.Cont'.cons₁ fs k)) →
((k : Turing.PartrecToTM2.Cont') → motive k.cons₂) →
((f : Turing.ToPartrec.Code) → (k : Turing.Partr... | false |
Lean.Server.ServerRequestResponse.success.sizeOf_spec | Lean.Server.Requests | ∀ {α : Type} [inst : SizeOf α] (response : α),
sizeOf (Lean.Server.ServerRequestResponse.success response) = 1 + sizeOf response | true |
OrderAddMonoidHom.snd.eq_1 | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β], OrderAddMonoidHom.snd α β = { toAddMonoidHom := AddMonoidHom.snd α β, monotone' := ⋯ } | true |
_private.Mathlib.RingTheory.Finiteness.Nilpotent.0.Matrix.isNilpotent_iff_forall_row._simp_1_1 | Mathlib.RingTheory.Finiteness.Nilpotent | ∀ {m : Type u_2} {α : Type u_11} [inst : CommSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m]
(M : Matrix m m α) (k : ℕ), M.transpose ^ k = (M ^ k).transpose | false |
Fin.succAbove_ne_last_last | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {a : Fin (n + 2)}, a ≠ Fin.last (n + 1) → a.succAbove (Fin.last n) = Fin.last (n + 1) | true |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.filterComparisons.match_1 | Mathlib.Tactic.Linarith.Preprocessing | (motive : Mathlib.Ineq → Sort u_1) →
(x : Mathlib.Ineq) →
(Unit → motive Mathlib.Ineq.le) → (Unit → motive Mathlib.Ineq.lt) → (Unit → motive Mathlib.Ineq.eq) → motive x | false |
_private.Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage.0.Dynamics.dynEntourage_comp_subset._simp_1_3 | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
_private.Lean.Data.Json.Basic.0.Lean.Json.hash' | Lean.Data.Json.Basic | Lean.Json → UInt64 | true |
RingQuot.instOne | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Semiring R] → (r : R → R → Prop) → One (RingQuot r) | true |
_private.Mathlib.Probability.Kernel.Disintegration.CondCDF.0.ProbabilityTheory.setLIntegral_preCDF_fst._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | false |
CommRingCat.instIsLocalHomCarrierPtWalkingParallelPairEqualizerForkRingHomHomι | Mathlib.Algebra.Category.Ring.Constructions | ∀ {A B : CommRingCat} (f g : A ⟶ B), IsLocalHom (CommRingCat.Hom.hom (CommRingCat.equalizerFork f g).ι) | true |
_private.Batteries.Data.List.Basic.0.List.takeWhile₂TR.go.match_1.splitter | Batteries.Data.List.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → List β → List α → List β → Sort u_3) →
(x : List α) →
(x_1 : List β) →
(x_2 : List α) →
(x_3 : List β) →
((a : α) →
(as : List α) →
(b : β) →
(bs : Lis... | true |
Finset.lcm_def | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
{f : β → α}, s.lcm f = (Multiset.map f s.val).lcm | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.withLetDecls.go._unary | Lean.Meta.Tactic.FunInd | {α : Type} →
Lean.Name →
Array Lean.Expr → Array Lean.Expr → (Array Lean.Expr → Lean.MetaM α) → (_ : ℕ) ×' Array Lean.Expr → Lean.MetaM α | false |
binomialSeries_radius_eq_one | Mathlib.Analysis.Analytic.Binomial | ∀ {𝕂 : Type v} [inst : RCLike 𝕂] {𝔸 : Type u} [inst_1 : NormedDivisionRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸] {a : 𝕂},
(∀ (k : ℕ), a ≠ ↑k) → (binomialSeries 𝔸 a).radius = 1 | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_69 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α)
(h : List.idxOfNth w [] [].length + 1 ≤ (List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w)) [a, g a, g (g a)])[List.idxOfNth w [] [].length] < [a, g a, g (g a)].length | false |
Bool.completeLinearOrder._proof_4 | Mathlib.Data.Fintype.Order | ∀ (a b c : Bool), a ≤ b ⇨ c ↔ min a b ≤ c | false |
ULift.seminormedCommRing._proof_10 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : SeminormedCommRing α] (n : ℕ), ↑(n + 1) = ↑n + 1 | false |
Lean.Meta.InfoCacheKey.expr | Lean.Meta.Basic | Lean.Meta.InfoCacheKey → Lean.Expr | true |
ProbabilityTheory.cauchyPDFReal | Mathlib.Probability.Distributions.Cauchy | ℝ → NNReal → ℝ → ℝ | true |
Choose.choose_modEq_choose_mod_mul_choose_div_nat | Mathlib.Data.Nat.Choose.Lucas | ∀ {n k p : ℕ} [Fact (Nat.Prime p)], n.choose k ≡ (n % p).choose (k % p) * (n / p).choose (k / p) [MOD p] | true |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity.0.MeasureTheory.eLpNorm'_le_nnreal_smul_eLpNorm'_of_ae_le_mul'._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ (x : ENNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.