name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Filter.monoid._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : Monoid α] (x : Filter α), npowRecAuto 0 x = 1 | false |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.name.match_7 | Lean.Elab.DocString.Builtin | (motive : Lean.Doc.DocScope → Sort u_1) →
(scope : Lean.Doc.DocScope) →
(Unit → motive Lean.Doc.DocScope.local) →
((xs : Array Lean.Name) → motive (Lean.Doc.DocScope.import xs)) → motive scope | false |
Lean.Meta.kabstract | Lean.Meta.KAbstract | Lean.Expr → Lean.Expr → optParam Lean.Meta.Occurrences Lean.Meta.Occurrences.all → Lean.MetaM Lean.Expr | true |
CategoryTheory.MonObj._aux_Mathlib_CategoryTheory_Monoidal_Grp____unexpand_CategoryTheory_GrpObj_inv_2 | Mathlib.CategoryTheory.Monoidal.Grp_ | Lean.PrettyPrinter.Unexpander | false |
AlgebraicGeometry.LocallyOfFiniteType.isLocallyNoetherian | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.LocallyOfFiniteType f]
[AlgebraicGeometry.IsLocallyNoetherian Y], AlgebraicGeometry.IsLocallyNoetherian X | true |
MDifferentiableWithinAt.clm_bundle_apply | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {M : Type u_6} [inst : NontriviallyNormedField 𝕜]
{E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)] [inst_2 : (x : B) → Module 𝕜 (E₁ x)]
[inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁] [inst_5 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)]
[inst_6 : (x : B) → TopologicalSpace (E₁ x)] {E₂ : B → Type u_8} [inst_7 : (x : B) → AddCommGroup (E₂ x)]
[inst_8 : (x : B) → Module 𝕜 (E₂ x)] [inst_9 : NormedAddCommGroup F₂] [inst_10 : NormedSpace 𝕜 F₂]
[inst_11 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)] [inst_12 : (x : B) → TopologicalSpace (E₂ x)] {EB : Type u_10}
[inst_13 : NormedAddCommGroup EB] [inst_14 : NormedSpace 𝕜 EB] {HB : Type u_11} [inst_15 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_16 : TopologicalSpace B] [inst_17 : ChartedSpace HB B] {EM : Type u_12}
[inst_18 : NormedAddCommGroup EM] [inst_19 : NormedSpace 𝕜 EM] {HM : Type u_13} [inst_20 : TopologicalSpace HM]
{IM : ModelWithCorners 𝕜 EM HM} [inst_21 : TopologicalSpace M] [inst_22 : ChartedSpace HM M]
[inst_23 : FiberBundle F₁ E₁] [inst_24 : VectorBundle 𝕜 F₁ E₁] [inst_25 : FiberBundle F₂ E₂]
[inst_26 : VectorBundle 𝕜 F₂ E₂] {b : M → B} {v : (x : M) → E₁ (b x)} {s : Set M} {x : M}
[inst_27 : ∀ (x : B), IsTopologicalAddGroup (E₂ x)] [inst_28 : ∀ (x : B), ContinuousSMul 𝕜 (E₂ x)]
{ϕ : (x : M) → E₁ (b x) →L[𝕜] E₂ (b x)}, MDiffAt[s] (T% ϕ) x → MDiffAt[s] (T% v) x → (MDiffAt[s] fun m => ⋯) x | true |
UInt64.ofFin_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : Fin UInt64.size), ↑b < 64 → UInt64.ofFin (a <<< b) = UInt64.ofFin a <<< UInt64.ofFin b | true |
_private.Mathlib.Combinatorics.Hall.Finite.0.HallMarriageTheorem.hall_cond_of_compl._simp_1_9 | Mathlib.Combinatorics.Hall.Finite | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
instCommMonoidUniformOnFun._proof_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : CommMonoid β] (a b : UniformOnFun α β 𝔖), a * b = b * a | false |
_private.Mathlib.Data.Vector.Basic.0.List.Vector.mOfFn.match_1.eq_1 | Mathlib.Data.Vector.Basic | ∀ {m : Type u_3 → Type u_2} {α : Type u_3} (motive : (x : ℕ) → (Fin x → m α) → Sort u_1) (x : Fin 0 → m α)
(h_1 : (x : Fin 0 → m α) → motive 0 x) (h_2 : (n : ℕ) → (f : Fin (n + 1) → m α) → motive n.succ f),
(match 0, x with
| 0, x => h_1 x
| n.succ, f => h_2 n f) =
h_1 x | true |
CategoryTheory.eId | Mathlib.CategoryTheory.Enriched.Basic | (V : Type v) →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
(X : C) → CategoryTheory.MonoidalCategoryStruct.tensorUnit V ⟶ X ⟶[V] X | true |
ENNReal.ofReal_lt_ofReal_iff._simp_1 | Mathlib.Data.ENNReal.Real | ∀ {p q : ℝ}, 0 < q → (ENNReal.ofReal p < ENNReal.ofReal q) = (p < q) | false |
CategoryTheory.Idempotents.Karoubi.HomologicalComplex.p_idem_assoc | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C c)) (n : ι) {Z : C}
(h : P.X.X n ⟶ Z),
CategoryTheory.CategoryStruct.comp (P.p.f n) (CategoryTheory.CategoryStruct.comp (P.p.f n) h) =
CategoryTheory.CategoryStruct.comp (P.p.f n) h | true |
LinearMap.instDistribMulAction | Mathlib.Algebra.Module.LinearMap.Defs | {R : Type u_1} →
{R₂ : Type u_3} →
{S : Type u_5} →
{M : Type u_8} →
{M₂ : Type u_10} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R₂ M₂] →
{σ₁₂ : R →+* R₂} →
[inst_6 : Monoid S] →
[inst_7 : DistribMulAction S M₂] →
[SMulCommClass R₂ S M₂] → DistribMulAction S (M →ₛₗ[σ₁₂] M₂) | true |
TwoSidedIdeal.orderIsoIdeal._proof_5 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {a b : TwoSidedIdeal R},
{ toFun := ⇑TwoSidedIdeal.asIdeal, invFun := ⇑TwoSidedIdeal.fromIdeal, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := ⇑TwoSidedIdeal.asIdeal, invFun := ⇑TwoSidedIdeal.fromIdeal, left_inv := ⋯, right_inv := ⋯ } b ↔
a ≤ b | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_insert._proof_1_16 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ (b : Bool), ¬b = true → b = false | false |
Rep.coinvariantsTensorMk._proof_2 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} [inst : CommRing k] [inst_1 : Monoid G] (A B : Rep.{u_1, u_1, u_2} k G),
SMulCommClass k k (TensorProduct k ↑A ↑B) | false |
Submodule.LinearDisjoint.mk._flat_ctor | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {M N : Submodule R S},
Function.Injective ⇑(M.mulMap N) → M.LinearDisjoint N | false |
Rat.sqrt_eq | Mathlib.Data.Rat.Sqrt | ∀ (q : ℚ), Rat.sqrt (q * q) = |q| | true |
SSet.stdSimplex.finSuccAboveOrderIsoFinset | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | {n : ℕ} → (i : Fin (n + 2)) → Fin (n + 1) ≃o ↥{i}ᶜ | true |
Finmap.mk.sizeOf_spec | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : SizeOf α] [inst_1 : (a : α) → SizeOf (β a)] (entries : Multiset (Sigma β))
(nodupKeys : entries.NodupKeys),
sizeOf { entries := entries, nodupKeys := nodupKeys } = 1 + sizeOf entries + sizeOf nodupKeys | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.coherenceHom.elim | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
t.ctorIdx = 4 →
((α : Mathlib.Tactic.BicategoryLike.CoherenceHom) →
motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.coherenceHom α)) →
motive t | false |
CategoryTheory.Limits.Bicone.toBinaryBiconeIsColimit._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (b : CategoryTheory.Limits.Bicone (CategoryTheory.Limits.pairFunction X Y))
(j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp (b.toBinaryBicone.toCocone.ι.app j)
(CategoryTheory.Iso.refl b.toBinaryBicone.toCocone.pt).hom =
b.toCocone.ι.app j | false |
Std.IterM.DefaultConsumers.forIn'._proof_4 | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} [inst : Std.Iterator α m β] (γ : Type u_3)
(PlausibleForInStep : β → γ → ForInStep γ → Prop) (P : β → Prop) (it : Std.IterM m β) (acc : γ)
(hP : ∀ (b : β), it.IsPlausibleIndirectOutput b → P b) (it' : Std.IterM m β) (out : β)
(h : it.IsPlausibleStep (Std.IterStep.yield it' out)) (c : γ),
PlausibleForInStep out acc (ForInStep.yield c) →
(∃ b,
(⟨it, ⟨acc, hP⟩⟩.fst, ⟨it, ⟨acc, hP⟩⟩.snd.fst).1.IsPlausibleStep
(Std.IterStep.yield (⟨it', ⟨c, ⋯⟩⟩.fst, ⟨it', ⟨c, ⋯⟩⟩.snd.fst).1 b) ∧
PlausibleForInStep b (⟨it, ⟨acc, hP⟩⟩.fst, ⟨it, ⟨acc, hP⟩⟩.snd.fst).2
(ForInStep.yield (⟨it', ⟨c, ⋯⟩⟩.fst, ⟨it', ⟨c, ⋯⟩⟩.snd.fst).2)) ∨
(⟨it, ⟨acc, hP⟩⟩.fst, ⟨it, ⟨acc, hP⟩⟩.snd.fst).1.IsPlausibleStep
(Std.IterStep.skip (⟨it', ⟨c, ⋯⟩⟩.fst, ⟨it', ⟨c, ⋯⟩⟩.snd.fst).1) ∧
(⟨it', ⟨c, ⋯⟩⟩.fst, ⟨it', ⟨c, ⋯⟩⟩.snd.fst).2 = (⟨it, ⟨acc, hP⟩⟩.fst, ⟨it, ⟨acc, hP⟩⟩.snd.fst).2 | false |
Std.DHashMap.Const.get!_eq_get! | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [inst : LawfulBEq α]
[inst_1 : Inhabited β] {a : α}, Std.DHashMap.Const.get! m a = m.get! a | true |
CategoryTheory.SemiadditiveOfBinaryBiproducts.addCommMonoidHomOfHasBinaryBiproducts._proof_4 | Mathlib.CategoryTheory.Preadditive.OfBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] (X Y : C) (a : X ⟶ Y),
CategoryTheory.SemiadditiveOfBinaryBiproducts.rightAdd X Y 0 a = a | false |
Set.IsPWO.mono | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, t.IsPWO → s ⊆ t → s.IsPWO | true |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevBetaS'.visit._unsafe_rec | Lean.Meta.Sym.InstantiateS | Array Lean.Expr → Lean.Expr → ℕ → Lean.Meta.Sym.M✝ Lean.Expr | false |
AlgebraicGeometry.IsReduced.mk._flat_ctor | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsReduced.component_reduced._autoParam →
AlgebraicGeometry.IsReduced X | false |
Ideal.mem_toTwoSided | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] {x : R}, x ∈ I.toTwoSided ↔ x ∈ I | true |
AddGroup.residuallyFinite_iff_forall_finiteIndex | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : AddGroup G],
AddGroup.ResiduallyFinite G ↔ ∀ (g : G), (∀ (H : AddSubgroup G) [H.FiniteIndex], g ∈ H) → g = 0 | true |
_private.Mathlib.Order.Filter.AtTopBot.Field.0.Filter.tendsto_mul_const_atBot_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α} [l.NeBot],
Filter.Tendsto (fun x => r * f x) l Filter.atBot =
(0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop) | false |
_private.Mathlib.RingTheory.DedekindDomain.SelmerGroup.0.«_aux_Mathlib_RingTheory_DedekindDomain_SelmerGroup___macroRules__private_Mathlib_RingTheory_DedekindDomain_SelmerGroup_0_term_/__1_1» | Mathlib.RingTheory.DedekindDomain.SelmerGroup | Lean.Macro | false |
CategoryTheory.SmallObject.SuccStruct.extendToSuccRestrictionLEIso_hom_app | 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} (hj : ¬IsMax j) (F : CategoryTheory.Functor (↑(Set.Iic j)) C) {X : C}
(τ : F.obj ⟨j, ⋯⟩ ⟶ X) (X_1 : ↑(Set.Iic j)),
(CategoryTheory.SmallObject.SuccStruct.extendToSuccRestrictionLEIso hj F τ).hom.app X_1 =
(CategoryTheory.SmallObject.SuccStruct.extendToSuccObjIso hj F τ ↑X_1 ⋯).hom | true |
SimpleGraph.cliqueFree_completeMultipartiteGraph | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {n : ℕ} {ι : Type u_3} [inst : Fintype ι] (V : ι → Type u_4),
Fintype.card ι < n → (SimpleGraph.completeMultipartiteGraph V).CliqueFree n | true |
Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.2070467515._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | false |
MeasureTheory.AEEqFun.pow_toGerm | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Monoid γ] [inst_3 : ContinuousMul γ] (f : α →ₘ[μ] γ) (n : ℕ), (f ^ n).toGerm = f.toGerm ^ n | true |
MulRingNorm.mulRingNormEquivAbsoluteValue_symm_apply | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : Nontrivial R] (v : AbsoluteValue R ℝ) (x : R),
(MulRingNorm.mulRingNormEquivAbsoluteValue.symm v) x = v x | true |
_private.Mathlib.Tactic.NormNum.Ordinal.0.Mathlib.Meta.NormNum.evalOrdinalMod._proof_1 | Mathlib.Tactic.NormNum.Ordinal | ∀ (an bn rn : Q(ℕ)), («$an» % «$bn») =Q «$rn» | false |
Associates.irreducible_iff_prime_iff | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M],
(∀ (a : M), Irreducible a ↔ Prime a) ↔ ∀ (a : Associates M), Irreducible a ↔ Prime a | true |
hfdifferential._proof_3 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_6} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_5}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_3} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_4} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_2} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : ContMDiffMap I I' M M' ↑⊤} {x : M}
{y : M'},
f x = y →
∀ (v : PointDerivation I x) (g g' : PointedContMDiffMap 𝕜 I' M' (↑⊤) y),
{ toFun := fun g => v (ContMDiffMap.comp g f), map_add' := ⋯, map_smul' := ⋯ } (g * g') =
g • { toFun := fun g => v (ContMDiffMap.comp g f), map_add' := ⋯, map_smul' := ⋯ } g' +
g' • { toFun := fun g => v (ContMDiffMap.comp g f), map_add' := ⋯, map_smul' := ⋯ } g | false |
Std.Internal.List.mem_iff_getKey?_eq_some_and_getValue?_eq_some | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [EquivBEq α] {β : Type v} {k : α} {v : β} {l : List ((_ : α) × β)},
Std.Internal.List.DistinctKeys l →
(⟨k, v⟩ ∈ l ↔ Std.Internal.List.getKey? k l = some k ∧ Std.Internal.List.getValue? k l = some v) | true |
Composition.recOnAppendSingle._proof_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {motive : (n : ℕ) → Composition n → Sort u_1} (k n : ℕ) (c : Composition n),
motive (k + 1 + n) ((Composition.single (k + 1) ⋯).append c).reverse =
motive (n + (k + 1)) (c.reverse.append (Composition.single (k + 1) ⋯)) | false |
Equiv.Perm.congr_arg | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {f : Equiv.Perm α} {x x' : α}, x = x' → f x = f x' | true |
FinVec.prod.eq_def | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : One α] (x : ℕ) (x_1 : Fin x → α),
FinVec.prod x_1 =
match x, x_1 with
| 0, x => 1
| 1, v => v 0
| n.succ.succ, v => (FinVec.prod fun i => v i.castSucc) * v (Fin.last (n + 1)) | true |
one_lt_mul_self_iff._simp_2 | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : LinearOrder α] [IsOrderedMonoid α] {a : α}, (1 < a * a) = (1 < a) | false |
Bot.ctorIdx | Mathlib.Order.Notation | {α : Type u_1} → Bot α → ℕ | false |
Quiver.Path.reverse | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} → [inst : Quiver V] → [Quiver.HasReverse V] → {a b : V} → Quiver.Path a b → Quiver.Path b a | true |
Homeomorph.addRight.eq_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : SeparatelyContinuousAdd G] (a : G),
Homeomorph.addRight a = { toEquiv := Equiv.addRight a, continuous_toFun := ⋯, continuous_invFun := ⋯ } | true |
_private.Init.Data.Nat.MinMax.0.Nat.add_min_add_right._simp_1_1 | Init.Data.Nat.MinMax | ∀ {m k n : ℕ}, (m + n ≤ k + n) = (m ≤ k) | false |
Quiver.Arborescence.ctorIdx | Mathlib.Combinatorics.Quiver.Arborescence | {V : Type u} → {inst : Quiver V} → Quiver.Arborescence V → ℕ | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.Context.mk._flat_ctor | Lean.Compiler.LCNF.ExplicitRC | Lean.FVarIdHashSet →
Lean.Compiler.LCNF.DerivedValMap✝ →
Lean.Compiler.LCNF.VarMap✝ → Lean.Compiler.LCNF.JPLiveVarMap✝ → ℕ → Lean.Compiler.LCNF.Context✝ | false |
Lean.Elab.Do.withDoBlockResultType | Lean.Elab.Do.Basic | {α : Type} → Lean.Expr → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM α | true |
LinearMap.tensorEqLocusBil._proof_12 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N] [inst_10 : Module R P]
(f g : N →ₗ[R] P),
SMulCommClass R S
↥(LinearMap.eqLocus ((TensorProduct.AlgebraTensorModule.lTensor S M) f)
((TensorProduct.AlgebraTensorModule.lTensor S M) g)) | false |
Option.isSome.eq_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (val : α), (some val).isSome = true | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cons_append_append._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ w₃ : ℕ}, ∀ i < w₁ + 1 + w₂ + w₃, ¬i < w₁ + w₂ + w₃ → i - w₃ - w₂ < w₁ → False | false |
_private.Lean.Elab.Deriving.DecEq.0.Lean.Elab.Deriving.DecEq.mkMatchOld.mkSameCtorRhs._unsafe_rec | Lean.Elab.Deriving.DecEq | List (Lean.Ident × Lean.Ident × Option Lean.Name × Bool) → Lean.Elab.TermElabM Lean.Term | false |
Lean.Lsp.instFromJsonPosition | Lean.Data.Lsp.BasicAux | Lean.FromJson Lean.Lsp.Position | true |
CategoryTheory.SimplicialThickening.Path.mk.inj | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} {inst : LinearOrder J} {i j : J} {I : Set J}
{left : autoParam (i ∈ I) CategoryTheory.SimplicialThickening.Path.left._autoParam}
{right : autoParam (j ∈ I) CategoryTheory.SimplicialThickening.Path.right._autoParam}
{left_le : autoParam (∀ k ∈ I, i ≤ k) CategoryTheory.SimplicialThickening.Path.left_le._autoParam}
{le_right : autoParam (∀ k ∈ I, k ≤ j) CategoryTheory.SimplicialThickening.Path.le_right._autoParam} {I_1 : Set J}
{left_1 : autoParam (i ∈ I_1) CategoryTheory.SimplicialThickening.Path.left._autoParam}
{right_1 : autoParam (j ∈ I_1) CategoryTheory.SimplicialThickening.Path.right._autoParam}
{left_le_1 : autoParam (∀ k ∈ I_1, i ≤ k) CategoryTheory.SimplicialThickening.Path.left_le._autoParam}
{le_right_1 : autoParam (∀ k ∈ I_1, k ≤ j) CategoryTheory.SimplicialThickening.Path.le_right._autoParam},
{ I := I, left := left, right := right, left_le := left_le, le_right := le_right } =
{ I := I_1, left := left_1, right := right_1, left_le := left_le_1, le_right := le_right_1 } →
I = I_1 | true |
instRingUniversalEnvelopingAlgebra._proof_39 | Mathlib.Algebra.Lie.UniversalEnveloping | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
autoParam (∀ (a : UniversalEnvelopingAlgebra R L), instRingUniversalEnvelopingAlgebra._aux_37 R L 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam | false |
AddSubgroup.instTop.eq_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G],
AddSubgroup.instTop =
{
top :=
let __src := ⊤;
{ toAddSubmonoid := __src, neg_mem' := ⋯ } } | true |
Lean.Parser.Attr._aux_Mathlib_Tactic_Simps_Basic___macroRules_Lean_Parser_Attr_attrSimps!?__1 | Mathlib.Tactic.Simps.Basic | Lean.Macro | false |
IntermediateField.copy | Mathlib.FieldTheory.IntermediateField.Basic | {K : Type u_1} →
{L : Type u_2} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] → (S : IntermediateField K L) → (s : Set L) → s = ↑S → IntermediateField K L | true |
Sublattice.comap | Mathlib.Order.Sublattice | {α : Type u_2} →
{β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom α β → Sublattice β → Sublattice α | true |
Finsupp.smul_single | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α) (b : M),
(c • fun₀ | a => b) = fun₀ | a => c • b | true |
CategoryTheory.GrothendieckTopology.isoToPlus.congr_simp | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functor Cᵒᵖ D) [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D]
(hP : CategoryTheory.Presheaf.IsSheaf J P), J.isoToPlus P hP = J.isoToPlus P hP | true |
PFunctor.M.bisim' | Mathlib.Data.PFunctor.Univariate.M | ∀ {P : PFunctor.{uA, uB}} {α : Type u_3} (Q : α → Prop) (u v : α → P.M),
(∀ (x : α),
Q x →
∃ a f f', (u x).dest = ⟨a, f⟩ ∧ (v x).dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x') →
∀ (x : α), Q x → u x = v x | true |
Asymptotics.isBigO_top._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F},
f =O[⊤] g = ∃ C, ∀ (x : α), ‖f x‖ ≤ C * ‖g x‖ | false |
CategoryTheory.OrthogonalReflection.D₁.ιLeft_comp_t_assoc | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W f) (g : X ⟶ Z) {Z_1 : C} (h : ∐ CategoryTheory.OrthogonalReflection.D₁.obj₂ ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιLeft f hf g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.t W Z) h) =
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιRight f hf g) h) | true |
CategoryTheory.Dial.recOn | Mathlib.CategoryTheory.Dialectica.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
{motive : CategoryTheory.Dial C → Sort u_1} →
(t : CategoryTheory.Dial C) →
((src tgt : C) →
(rel : CategoryTheory.Subobject (src ⨯ tgt)) → motive { src := src, tgt := tgt, rel := rel }) →
motive t | false |
List.length_destutter_le_length_destutter_cons | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] {a : α} [IsEquiv α Rᶜ] {l : List α},
(List.destutter R l).length ≤ (List.destutter R (a :: l)).length | true |
StarSubsemiring.center | Mathlib.Algebra.Star.Subsemiring | (R : Type u_1) → [inst : NonAssocSemiring R] → [inst_1 : StarRing R] → StarSubsemiring R | true |
Subtype.coe_bot | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : OrderBot (Subtype p)],
p ⊥ → ↑⊥ = ⊥ | true |
Finset.map_swap_antidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_1} [inst : AddCommMonoid A] [inst_1 : Finset.HasAntidiagonal A] {n : A},
Finset.map { toFun := Prod.swap, inj' := ⋯ } (Finset.antidiagonal n) = Finset.antidiagonal n | true |
Rep.RepToAction_obj_V_carrier | Mathlib.RepresentationTheory.Rep.Basic | ∀ (k : Type u) (G : Type v) [inst : Ring k] [inst_1 : Monoid G] (X : Rep.{w, u, v} k G),
↑((Rep.RepToAction k G).obj X).V = ↑X | true |
AddAction.ext | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} {inst : AddMonoid G} {x y : AddAction G P}, VAdd.vadd = VAdd.vadd → x = y | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balRight.match_1.splitter._sparseCasesOn_4 | Batteries.Data.RBMap.WF | {motive : Batteries.RBColor → Sort u} →
(t : Batteries.RBColor) → motive Batteries.RBColor.black → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.getPPAnalyzeExplicitHoles | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Options → Bool | true |
TopologicalSpace.Closeds.iInf_def | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] {ι : Sort u_4} (s : ι → TopologicalSpace.Closeds α),
⨅ i, s i = { carrier := ⋂ i, ↑(s i), isClosed' := ⋯ } | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Ordered.append.match_1_15 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} (a : Batteries.RBNode α) (x : α) (b : Batteries.RBNode α)
(motive : Batteries.RBNode.Ordered cmp (Batteries.RBNode.node Batteries.RBColor.black a x b) → Prop)
(hl : Batteries.RBNode.Ordered cmp (Batteries.RBNode.node Batteries.RBColor.black a x b)),
(∀ (ax : Batteries.RBNode.All (fun x_1 => Batteries.RBNode.cmpLT cmp x_1 x) a)
(xb : Batteries.RBNode.All (fun x_1 => Batteries.RBNode.cmpLT cmp x x_1) b) (ha : Batteries.RBNode.Ordered cmp a)
(hb : Batteries.RBNode.Ordered cmp b), motive ⋯) →
motive hl | false |
_private.Batteries.Data.RBMap.Alter.0.Batteries.RBNode.Path.Ordered.fill.match_1_1 | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} (motive : Batteries.RBNode.Path α → Batteries.RBNode α → Prop) (x : Batteries.RBNode.Path α)
(x_1 : Batteries.RBNode α),
(∀ (x : Batteries.RBNode α), motive Batteries.RBNode.Path.root x) →
(∀ (c : Batteries.RBColor) (parent : Batteries.RBNode.Path α) (v : α) (r x : Batteries.RBNode α),
motive (Batteries.RBNode.Path.left c parent v r) x) →
(∀ (c : Batteries.RBColor) (l : Batteries.RBNode α) (v : α) (parent : Batteries.RBNode.Path α)
(x : Batteries.RBNode α), motive (Batteries.RBNode.Path.right c l v parent) x) →
motive x x_1 | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_left._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
SimpleGraph.nonempty_hom_of_forall_finite_subgraph_hom | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {W : Type v} {G : SimpleGraph V} {F : SimpleGraph W} [Finite W]
(h : (G' : G.Subgraph) → G'.verts.Finite → G'.coe →g F), Nonempty (G →g F) | true |
Tree.noConfusion | Mathlib.Data.Tree.Basic | {P : Sort u_1} →
{α : Type u} → {t : Tree α} → {α' : Type u} → {t' : Tree α'} → α = α' → t ≍ t' → Tree.noConfusionType P t t' | false |
Ideal.Quotient.divisionRing._proof_9 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] [inst_2 : I.IsMaximal], 0⁻¹ = 0 | false |
WellFoundedRelation.isWellFounded | Mathlib.Order.RelClasses | ∀ {α : Type u} [h : WellFoundedRelation α], IsWellFounded α WellFoundedRelation.rel | true |
Float32.recOn | Init.Data.Float32 | {motive : Float32 → Sort u} → (t : Float32) → ((val : float32Spec.float) → motive { val := val }) → motive t | false |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.upperHemicontinuousWithinAt_singleton_iff._simp_1_2 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, ∀ᶠ (x : α) in l₁, f x ∈ s | false |
LinearIsometryEquiv.symm_apply_apply | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Module R₂ E₂]
(e : E ≃ₛₗᵢ[σ₁₂] E₂) (x : E), e.symm (e x) = x | true |
Int.dvd_emod_sub_self | Init.Data.Int.DivMod.Lemmas | ∀ {x m : ℤ}, m ∣ x % m - x | true |
_private.Mathlib.Algebra.Homology.ShortComplex.ExactFunctor.0.CategoryTheory.Functor.preservesFiniteLimits_tfae.match_1_1 | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive]
(motive :
(∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f)) →
(x : CategoryTheory.ShortComplex C) → x.Exact ∧ CategoryTheory.Mono x.f → Prop)
(x : ∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f))
(x_1 : CategoryTheory.ShortComplex C) (x_2 : x_1.Exact ∧ CategoryTheory.Mono x_1.f),
(∀ (hF : ∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f))
(S : CategoryTheory.ShortComplex C) (hS : S.Exact) (hf : CategoryTheory.Mono S.f), motive hF S ⋯) →
motive x x_1 x_2 | false |
isAddCyclic_of_card_nsmul_eq_zero_le | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : DecidableEq α] [inst_2 : Fintype α],
(∀ (n : ℕ), 0 < n → {a | n • a = 0}.card ≤ n) → IsAddCyclic α | true |
Lean.Grind.CommRing.Poly.mulM | Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Meta.Grind.Arith.CommRing.RingM Lean.Grind.CommRing.Poly | true |
InfTopHom.dual._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : Top α] [inst_2 : Min β] [inst_3 : Top β],
Function.LeftInverse (fun f => { toInfHom := InfHom.dual.symm f.toSupHom, map_top' := ⋯ }) fun f =>
{ toSupHom := InfHom.dual f.toInfHom, map_bot' := ⋯ } | false |
Set.bounded_ge_inter_ge | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Bounded (fun x1 x2 => x1 ≥ x2) (s ∩ {b | b ≤ a}) ↔ Set.Bounded (fun x1 x2 => x1 ≥ x2) s | true |
DirectSum.IsInternal.collectedBasis_orthonormal | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} [inst_3 : DecidableEq ι] {V : ι → Submodule 𝕜 E},
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) →
∀ (hV_sum : DirectSum.IsInternal fun i => V i) {α : ι → Type u_6}
{v_family : (i : ι) → Module.Basis (α i) 𝕜 ↥(V i)},
(∀ (i : ι), Orthonormal 𝕜 ⇑(v_family i)) → Orthonormal 𝕜 ⇑(hV_sum.collectedBasis v_family) | true |
CategoryTheory.CommShift₂Setup.hε | Mathlib.CategoryTheory.Shift.CommShiftTwo | ∀ {D : Type u_5} [inst : CategoryTheory.Category.{v_5, u_5} D] {M : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : CategoryTheory.HasShift D M] (self : CategoryTheory.CommShift₂Setup D M) (m n : M),
self.ε m n = (self.z (0, n) (m, 0))⁻¹ * self.z (m, 0) (0, n) | true |
HasFPowerSeriesAt.has_fpower_series_iterate_dslope_fslope | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {f : 𝕜 → E} {z₀ : 𝕜} (n : ℕ),
HasFPowerSeriesAt f p z₀ →
HasFPowerSeriesAt ((Function.swap dslope z₀)^[n] f) (FormalMultilinearSeries.fslope^[n] p) z₀ | true |
ContinuousAlternatingMap.alternatizeUncurryFinCLM._proof_1 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ (𝕜 : Type u_3) (E : Type u_2) (F : Type u_1) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(f : E →L[𝕜] E [⋀^Fin n]→L[𝕜] F) (v : Fin (n + 1) → E),
‖(ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux✝ f) v‖ ≤ ∑ i, ‖f‖ * ∏ i, ‖v i‖ | false |
Equiv.Perm.OnCycleFactors.odd_of_centralizer_le_alternatingGroup | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {g : Equiv.Perm α},
Subgroup.centralizer {g} ≤ alternatingGroup α → ∀ i ∈ g.cycleType, Odd i | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.