name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
DirectSum.GradeZero.ring._proof_9 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddMonoid ι] (x : ℤ) (x_1 : A 0), (DirectSum.of A 0) (x • x_1) = x • (DirectSum.of A 0) x_1 | false |
_private.Init.Data.String.Basic.0.Nat.repeat.match_1.eq_2 | Init.Data.String.Basic | ∀ {α : Type u_2} (motive : ℕ → α → Sort u_1) (n : ℕ) (a : α) (h_1 : (a : α) → motive 0 a)
(h_2 : (n : ℕ) → (a : α) → motive n.succ a),
(match n.succ, a with
| 0, a => h_1 a
| n.succ, a => h_2 n a) =
h_2 n a | true |
subset_mul_closure_one | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type u_1} [inst : MulOneClass G] [inst_1 : TopologicalSpace G] (s : Set G), s ⊆ s * closure {1} | true |
ContinuousLinearEquiv.arrowCongrEquiv._proof_3 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_7} {R₃ : Type u_5} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_3}
... | false |
Finset.univ_perm_option | Mathlib.GroupTheory.Perm.Option | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
Finset.univ = Finset.map Equiv.Perm.decomposeOption.symm.toEmbedding Finset.univ | true |
Rat.toDyadic_mkRat | Init.Data.Dyadic.Basic | ∀ (a : ℤ) (b : ℕ) (prec : ℤ),
(mkRat a b).toDyadic prec = Dyadic.ofIntWithPrec (a <<< prec.toNat / ↑(b <<< (-prec).toNat)) prec | true |
Lean.Grind.AC.Expr.var.noConfusion | Init.Grind.AC | {P : Sort u} → {x x' : Lean.Grind.AC.Var} → Lean.Grind.AC.Expr.var x = Lean.Grind.AC.Expr.var x' → (x = x' → P) → P | false |
LowerSet.instMin._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s t : LowerSet α), IsLowerSet (↑s ∩ ↑t) | false |
CategoryTheory.Functor.IsRepresentedBy.rec | Mathlib.CategoryTheory.RepresentedBy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} →
{X : C} →
{x : F.obj (Opposite.op X)} →
{motive : F.IsRepresentedBy x → Sort u_1} →
((map_bijective : ∀ {Y : C}, Function.Bijective fun f => F.map f.op x) → motive ⋯) →
... | false |
CategoryTheory.OrthogonalReflection.iteration_map_succ_injectivity | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_3 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct Categ... | true |
Lean.IR.CollectUsedDecls.State.rec | Lean.Compiler.IR.EmitUtil | {motive : Lean.IR.CollectUsedDecls.State → Sort u} →
((set : Lean.NameSet) → (order : Array Lean.Name) → motive { set := set, order := order }) →
(t : Lean.IR.CollectUsedDecls.State) → motive t | false |
String.Legacy.Iterator.ValidFor.mk | Batteries.Data.String.Lemmas | ∀ {l r : List Char},
String.Legacy.Iterator.ValidFor l r { s := String.ofList (l.reverseAux r), i := { byteIdx := String.utf8Len l } } | true |
Std.DHashMap.Const.get?_eq_some_getD | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {a : α} {fallback : β},
a ∈ m → Std.DHashMap.Const.get? m a = some (Std.DHashMap.Const.getD m a fallback) | true |
MultilinearMap.constOfIsEmpty._proof_2 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ (R : Type u_4) {ι : Type u_1} (M₁ : ι → Type u_3) {M₂ : Type u_2} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [IsEmpty ι] (m : M₂) [inst_6 : DecidableEq ι] (x : (i : ι) → M₁ i) (a : ι) (c : R)
(x_1 : M₁ a),... | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Sync.forIn._unsafe_rec | Std.Sync.Channel | {m : Type → Type u_1} →
{α β : Type} → [Monad m] → [MonadLiftT BaseIO m] → Std.CloseableChannel.Sync α → (α → β → m (ForInStep β)) → β → m β | false |
CategoryTheory.Types.instConcreteCategory | Mathlib.CategoryTheory.ConcreteCategory.Forget | CategoryTheory.ConcreteCategory (Type u) fun X Y => X ⟶ Y | true |
Lean.Parser.Term.termFor.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | true |
CategoryTheory.OplaxFunctor.mk.inj | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C}
{mapId :
(a : B) →
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.id a) ⟶
CategoryTheory.CategoryStruct.id (toPrelaxFunctor.obj a)}
{... | true |
Std.Slice.mk.noConfusion | Init.Data.Slice.Basic | {γ : Type u} →
{P : Sort u_1} →
{internalRepresentation internalRepresentation' : γ} →
{ internalRepresentation := internalRepresentation } = { internalRepresentation := internalRepresentation' } →
(internalRepresentation ≍ internalRepresentation' → P) → P | false |
LawfulBitraversable.toLawfulBifunctor | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} {inst : Bitraversable t} [self : LawfulBitraversable t], LawfulBifunctor t | true |
_private.Lean.Util.CollectAxioms.0.Lean.ExportedAxiomsState.mk.inj | Lean.Util.CollectAxioms | ∀ {importedModuleEntries importedModuleEntries_1 : Array (Array (Lean.Name × Array Lean.Name))},
{ importedModuleEntries := importedModuleEntries } = { importedModuleEntries := importedModuleEntries_1 } →
importedModuleEntries = importedModuleEntries_1 | true |
CategoryTheory.ShortComplex.Exact.desc | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S : CategoryTheory.ShortComplex C} →
[CategoryTheory.Balanced C] →
S.Exact →
{A : C} →
(k : S.X₂ ⟶ A) → CategoryTheory.CategoryStruct.comp S.f k = 0 → [Cate... | true |
Real.rpowIntegrand₀₁_eq_pow_div | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p t x : ℝ}, p ∈ Set.Ioo 0 1 → 0 ≤ t → 0 ≤ x → p.rpowIntegrand₀₁ t x = t ^ (p - 1) * x / (t + x) | true |
Int.le | Init.Data.Int.Basic | ℤ → ℤ → Prop | true |
MvPolynomial.totalDegree_eq | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p : MvPolynomial σ R),
p.totalDegree = p.support.sup fun m => (Finsupp.toMultiset m).card | true |
CSA | Mathlib.Algebra.BrauerGroup.Defs | (K : Type u) → [Field K] → Type (max u (v + 1)) | true |
AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec._aux_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme___macroRules_AlgebraicGeometry_ProjIsoSpecTopComponent_FromSpec_tacticMem_tac_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.Macro | false |
List.TProd | Mathlib.Data.Prod.TProd | {ι : Type u} → (ι → Type v) → List ι → Type v | true |
Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit!_cons | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} {l : List α} {k : α},
↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t (k :: l)) =
↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! (Std.DTreeMap.Internal.Impl.insertIfNew! k () t) l) | true |
UniformSpace.mk._flat_ctor | Mathlib.Topology.UniformSpace.Defs | {α : Type u} →
(IsOpen : Set α → Prop) →
(isOpen_univ : IsOpen Set.univ) →
(isOpen_inter : ∀ (s t : Set α), IsOpen s → IsOpen t → IsOpen (s ∩ t)) →
(isOpen_sUnion : ∀ (s : Set (Set α)), (∀ t ∈ s, IsOpen t) → IsOpen (⋃₀ s)) →
(uniformity : Filter (α × α)) →
Filter.Tendsto Prod.s... | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.select | Std.Sync.Channel | {α : Type} → Std.Internal.IO.Async.Waiter (Option α) → Std.CloseableChannel.Consumer✝ α | true |
Std.TreeMap.Equiv.mergeWith | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ t₄ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] (f : α → β → β → β),
t₁.Equiv t₂ → t₃.Equiv t₄ → (Std.TreeMap.mergeWith f t₁ t₃).Equiv (Std.TreeMap.mergeWith f t₂ t₄) | true |
Subfield.instMulDistribMulActionSubtypeMem._proof_1 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {X : Type u_2} [inst_1 : Monoid X] [inst_2 : MulDistribMulAction K X]
(F : Subfield K) (r : ↥F.toSubsemiring) (b₁ b₂ : X), ↑r • (b₁ * b₂) = ↑r • b₁ * ↑r • b₂ | false |
BitVec.msb_setWidth'' | Init.Data.BitVec.Lemmas | ∀ {w k : ℕ} (x : BitVec w), (BitVec.setWidth (k + 1) x).msb = x.getLsbD k | true |
Module.length.eq_1 | Mathlib.RingTheory.Length | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.length R M = (Order.krullDim (Submodule R M)).unbot ⋯ | true |
AddGrpCat.FilteredColimits.colimit_add_mk_eq | Mathlib.Algebra.Category.Grp.FilteredColimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J AddGrpCat) (x y : (j : J) × ↑(F.obj j)) (k : J) (f : x.fst ⟶ k) (g : y.fst ⟶ k),
AddGrpCat.FilteredColimits.G.mk F x + AddGrpCat.FilteredColimits.G.mk F y =
AddGrpCat.FilteredColimits.G.mk... | true |
LocallyFiniteOrderBot.mk.noConfusion | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
{inst : Preorder α} →
{P : Sort u} →
{finsetIio finsetIic : α → Finset α} →
{finset_mem_Iic : ∀ (a x : α), x ∈ finsetIic a ↔ x ≤ a} →
{finset_mem_Iio : ∀ (a x : α), x ∈ finsetIio a ↔ x < a} →
{finsetIio' finsetIic' : α → Finset α} →
{finset_mem_Ii... | false |
Finset.expect_mul_expect | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Semiring M] [inst_1 : Module ℚ≥0 M] [IsScalarTower ℚ≥0 M M]
[SMulCommClass ℚ≥0 M M] (s : Finset ι) (t : Finset κ) (f : ι → M) (g : κ → M),
((s.expect fun i => f i) * t.expect fun j => g j) = s.expect fun i => t.expect fun j => f i * g j | true |
Submodule.exists_isInternal_prime_power_torsion | Mathlib.Algebra.Module.DedekindDomain | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] {M : Type v} [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[IsDedekindDomain R] [Module.Finite R M],
Module.IsTorsion R M →
∃ P x, ∃ (_ : ∀ p ∈ P, Prime p), ∃ e, DirectSum.IsInternal fun p => Submodule.torsionBySet R M ↑(↑p ^ e p) | true |
_private.Mathlib.Algebra.ContinuedFractions.Translations.0.GenContFract.contsAux.match_1.eq_1 | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} (motive : Option (GenContFract.Pair K) → Sort u_2) (h_1 : Unit → motive none)
(h_2 : (gp : GenContFract.Pair K) → motive (some gp)),
(match none with
| none => h_1 ()
| some gp => h_2 gp) =
h_1 () | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.inter_congr._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | false |
IO.CancelToken.isSet | Init.System.IO | IO.CancelToken → BaseIO Bool | true |
CategoryTheory.SplitMonoCategory.mk | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
(∀ {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f], CategoryTheory.IsSplitMono f) → CategoryTheory.SplitMonoCategory C | true |
Submodule.CoFG.ker | Mathlib.RingTheory.Finiteness.Cofinite | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] [IsNoetherian R N] (f : M →ₗ[R] N), f.ker.CoFG | true |
HasFPowerSeriesOnBall.prod | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {e : E} {f : E → F} {g : E → G} {r s ... | true |
cfcₙHom_of_cfcHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | (R : Type u_1) →
{A : Type u_2} →
{p : A → Prop} →
[inst : Semifield R] →
[inst_1 : StarRing R] →
[inst_2 : MetricSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Ring A] →
[inst_6 : StarRing... | true |
Std.DTreeMap.Internal.Impl.forInStep.match_1 | Std.Data.DTreeMap.Internal.Queries | {δ : Type u_1} →
(motive : ForInStep δ → Sort u_2) →
(__do_lift : ForInStep δ) →
((d : δ) → motive (ForInStep.done d)) → ((d : δ) → motive (ForInStep.yield d)) → motive __do_lift | false |
LieAlgebra.IsKilling.rootSystem._proof_7 | Mathlib.Algebra.Lie.Weights.RootSystem | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : LieAlgebra.IsKilling K L] [inst_5 : FiniteDimensional K L] (H : LieSubalgebra K L)
[inst_6 : H.IsCartanSubalgebra] [inst_7 : LieModule.IsTriangularizable K (↥H) L] (i : ↥LieSubalgebra.root... | false |
_private.Lean.Elab.DocString.0.Lean.Doc.ElabFootnote.mk | Lean.Elab.DocString | Lean.StrLit → Lean.Doc.ElabFootnote✝ | true |
Lean.Compiler.LCNF.CacheExtension.mk.injEq | Lean.Compiler.LCNF.CompilerM | ∀ {α β : Type} [inst : BEq α] [inst_1 : Hashable α]
(toEnvExtension toEnvExtension_1 : Lean.EnvExtension (List α × Lean.PHashMap α β)),
({ toEnvExtension := toEnvExtension } = { toEnvExtension := toEnvExtension_1 }) = (toEnvExtension = toEnvExtension_1) | true |
_private.Mathlib.Algebra.Lie.Subalgebra.0.LieSubalgebra.instInfSet._simp_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M)
{x : M}, (x ∈ p.carrier) = (x ∈ ↑p) | false |
Lean.PersistentEnvExtension.setState | Lean.Environment | {α β σ : Type} → Lean.PersistentEnvExtension α β σ → Lean.Environment → σ → Lean.Environment | true |
Std.DTreeMap.instSliceableRooSlice | Std.Data.DTreeMap.Slice | {α : Type u} →
{β : α → Type v} →
(cmp : autoParam (α → α → Ordering) Std.DTreeMap.instSliceableRooSlice._auto_1) →
Std.Roo.Sliceable (Std.DTreeMap α β cmp) α (Std.DTreeMap.Internal.RooSlice α β) | true |
Finset.Ioc_toDual | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : α),
Finset.Ioc (OrderDual.toDual a) (OrderDual.toDual b) = Finset.map OrderDual.toDual.toEmbedding (Finset.Ico b a) | true |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.elabGrindSuggestions.match_1 | Lean.Elab.Tactic.Grind.Main | (motive : Option String → Sort u_1) →
(x : Option String) → ((flag : String) → motive (some flag)) → (Unit → motive none) → motive x | false |
Order.IsPredLimit.lt_sub_natCast | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} {x y : α} [inst : PartialOrder α] [inst_1 : AddCommGroupWithOne α] [PredSubOrder α],
Order.IsPredLimit x → x < y → ∀ (n : ℕ), x < y - ↑n | true |
Topology.IsOpenEmbedding.mk._flat_ctor | Mathlib.Topology.Defs.Induced | ∀ {X : Type u_1} {Y : Type u_2} [tX : TopologicalSpace X] [tY : TopologicalSpace Y] {f : X → Y},
tX = TopologicalSpace.induced f tY → Function.Injective f → IsOpen (Set.range f) → Topology.IsOpenEmbedding f | false |
SemiconjBy.tsum_left | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : NonUnitalNonAssocSemiring α]
[inst_1 : TopologicalSpace α] [IsTopologicalSemiring α] {f : ι → α} [T2Space α] [L.NeBot] {a b : α},
(∀ (i : ι), SemiconjBy (f i) a b) → SemiconjBy (∑'[L] (i : ι), f i) a b | true |
AddCommGrpCat.limitAddCommGroup._aux_4 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J AddCommGrpCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections] →
AddCommGroup ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections →
(CategoryTh... | false |
Lean.Server.References.DocumentRefInfo.ctorIdx | Lean.Server.References | Lean.Server.References.DocumentRefInfo → ℕ | false |
Even.neg | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even a → Even (-a) | true |
Lean.Meta.Sym.Simp.instInhabitedConfig.default | Lean.Meta.Sym.Simp.SimpM | Lean.Meta.Sym.Simp.Config | true |
Asymptotics.IsBigOTVS.of_egauge_le_mul | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousConstSMul... | true |
Std.Internal.IO.Async.Signal._sizeOf_inst | Std.Internal.Async.Signal | SizeOf Std.Internal.IO.Async.Signal | false |
List.formPerm_rotate_one | Mathlib.GroupTheory.Perm.List | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), l.Nodup → (l.rotate 1).formPerm = l.formPerm | true |
HNNExtension.NormalWord.rec | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} →
{d : HNNExtension.NormalWord.TransversalPair G A B} →
{motive : HNNExtension.NormalWord d → Sort u} →
((toReducedWord : HNNExtension.NormalWord.ReducedWord G A B) →
(mem_set : ∀ (u : ℤˣ) (g : G), (u, g) ∈ toReducedWord.... | false |
CategoryTheory.HasSeparator.hasCoseparator_op | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.HasSeparator C],
CategoryTheory.HasCoseparator Cᵒᵖ | true |
LinearOrder.toPartialOrder_injective | Mathlib.Order.Basic | ∀ {α : Type u_2}, Function.Injective (@LinearOrder.toPartialOrder α) | true |
ENorm.enorm | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → [self : ENorm E] → E → ENNReal | true |
Std.Tactic.BVDecide.Normalize.Bool.and_right | Std.Tactic.BVDecide.Normalize.Bool | ∀ (lhs rhs : Bool), (lhs && rhs) = true → rhs = true | true |
Cardinal.instReprQuaternionAlgebra | Mathlib.Algebra.Quaternion | {R : Type u_1} → [Repr R] → {a b c : R} → Repr (QuaternionAlgebra R a b c) | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.Internal.List.insertEntryIfNew.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (k : α) (v : β k) (l : List ((a : α) × β a)),
Std.Internal.List.insertEntryIfNew k v l = bif Std.Internal.List.containsKey k l then l else ⟨k, v⟩ :: l | true |
Lean.Compiler.LCNF.Param.mk.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId : Lean.FVarId} →
{binderName : Lean.Name} →
{type : Lean.Expr} →
{borrow : Bool} →
{fvarId' : Lean.FVarId} →
{binderName' : Lean.Name} →
{type' : Lean.Expr} →
{borrow' : Bo... | false |
Finset.ruzsa_triangle_inequality_div_mul_div | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : CommGroup G] (A B C : Finset G),
(A / C).card * B.card ≤ (A * B).card * (B / C).card | true |
_private.Lean.Compiler.LCNF.ExpandResetReuse.0.Lean.Compiler.LCNF.processResetCont.match_5 | Lean.Compiler.LCNF.ExpandResetReuse | (motive : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.impure → Sort u_1) →
(x : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.impure) →
((y : Lean.FVarId) →
(c : Lean.Compiler.LCNF.CtorInfo) →
(u : Bool) →
(xs : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purit... | false |
FreeAddGroup.sum.of | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} [inst : AddGroup α] {x : α}, FreeAddGroup.sum (FreeAddGroup.of x) = x | true |
ComplexShape.next | Mathlib.Algebra.Homology.ComplexShape | {ι : Type u_1} → ComplexShape ι → ι → ι | true |
stdNext | Init.Data.Random | StdGen → ℕ × StdGen | true |
List.countP_flatten | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {l : List (List α)}, List.countP p l.flatten = (List.map (List.countP p) l).sum | true |
_private.Mathlib.Algebra.Homology.ShortComplex.ExactFunctor.0.CategoryTheory.Functor.preservesFiniteColimits_tfae.match_1_6 | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Abelian C] (F : CategoryTheory.Functor C D)
(motive : CategoryTheory.Limits.PreservesFiniteColimits F → (x : CategoryTheory.ShortComplex C) → x.ShortExact → Prop)
... | false |
Finsupp.mapRange.zeroHom_apply | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : Zero M] [inst_1 : Zero N] (f : ZeroHom M N) (g : ι →₀ M),
(Finsupp.mapRange.zeroHom f) g = Finsupp.mapRange ⇑f ⋯ g | true |
_private.Mathlib.Algebra.Ring.Parity.0.Nat.odd_sub'._proof_1_1 | Mathlib.Algebra.Ring.Parity | ∀ {m n : ℕ}, n ≤ m → (Odd (m - n) ↔ (Odd n ↔ Even m)) | false |
CategoryTheory.LiftRightAdjoint.constructRightAdjointEquiv._proof_2 | Mathlib.CategoryTheory.Adjunction.Lifting.Right | ∀ {A : Type u_2} {B : Type u_4} {C : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} A]
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] [inst_2 : CategoryTheory.Category.{u_5, u_6} C]
{U : CategoryTheory.Functor A B} {F : CategoryTheory.Functor B A} (L : CategoryTheory.Functor C B) (adj₁ : F ⊣ U)
(Y : C) (X ... | false |
StandardEtalePair.lift_X_left | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R), P.lift P.X ⋯ = AlgHom.id R P.Ring | true |
Int32.xor_zero | Init.Data.SInt.Bitwise | ∀ {a : Int32}, a ^^^ 0 = a | true |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleHover.match_12 | Lean.Server.FileWorker.RequestHandling | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((range : Lean.Syntax.Range) → motive (some range)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x | false |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.IsUnramifiedAtInfinitePlaces.card_infinitePlace._simp_1_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | false |
Mathlib.Meta.FunProp.Context.noConfusion | Mathlib.Tactic.FunProp.Types | {P : Sort u} → {t t' : Mathlib.Meta.FunProp.Context} → t = t' → Mathlib.Meta.FunProp.Context.noConfusionType P t t' | false |
Mathlib.Tactic.LibraryRewrite.rw??Command | Mathlib.Tactic.Widget.LibraryRewrite | Lean.ParserDescr | true |
Submodule.comm_trans_rTensorOne | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (M : Submodule R S),
TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne = M.lTensorOne | true |
Std.DHashMap.Raw.getD.congr_simp | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
(m m_1 : Std.DHashMap.Raw α β),
m = m_1 → ∀ (a : α) (fallback fallback_1 : β a), fallback = fallback_1 → m.getD a fallback = m_1.getD a fallback_1 | true |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult | Lean.Meta.Sym.Simp.Have | Type | true |
ZSpan.fractRestrict_surjective | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι], Function.Surjective (ZSpan.fractRestrict b) | true |
Lean.Grind.IntModule.add_zsmul | Init.Grind.Module.Basic | ∀ {M : Type u} [self : Lean.Grind.IntModule M] (n m : ℤ) (a : M), (n + m) • a = n • a + m • a | true |
IsAlgClosure.isAlgClosed | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (R : Type u) {K : Type v} {inst : CommRing R} {inst_1 : Field K} {inst_2 : Algebra R K}
{inst_3 : Module.IsTorsionFree R K} [self : IsAlgClosure R K], IsAlgClosed K | true |
modularCyclotomicCharacter.congr_simp | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | ∀ (L : Type u) [inst : CommRing L] [inst_1 : IsDomain L] {n : ℕ} [inst_2 : NeZero n]
(hn : Fintype.card ↥(rootsOfUnity n L) = n), modularCyclotomicCharacter L hn = modularCyclotomicCharacter L hn | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int8.instUpwardEnumerable._proof_2 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int8), Int8.minValue.toInt ≤ i.toInt → Int8.minValue.toInt ≤ i.toInt + ↑n | false |
Submodule.mem_toNonUnitalSubalgebra | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
{p : Submodule R A} {h_mul : ∀ (x y : A), x ∈ p → y ∈ p → x * y ∈ p} {x : A},
x ∈ p.toNonUnitalSubalgebra h_mul ↔ x ∈ p | true |
Subgroup.strictPeriods.eq_1 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)),
𝒢.strictPeriods = AddSubgroup.comap Matrix.GeneralLinearGroup.upperRightHom.toAddMonoidHom (Subgroup.toAddSubgroup 𝒢) | true |
Lean.Elab.Term.elabMutualDef | Lean.Elab.MutualDef | Array Lean.Expr → Lean.Elab.Command.Scope → Array Lean.Elab.DefView → Lean.Elab.TermElabM Unit | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.