name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Equiv.Perm.equivUnitsEnd._proof_6 | Mathlib.Algebra.Group.End | ∀ {α : Type u_1} (x x_1 : Equiv.Perm α), ⇑(Equiv.symm (x * x_1)) ∘ ⇑(x * x_1) = id |
_private.Mathlib.Data.Int.Bitwise.0.Int.shiftLeft_eq_mul_pow.match_1_1 | Mathlib.Data.Int.Bitwise | ∀ (motive : ℤ → ℕ → Prop) (x : ℤ) (x_1 : ℕ),
(∀ (m x : ℕ), motive (Int.ofNat m) x) → (∀ (a x : ℕ), motive (Int.negSucc a) x) → motive x x_1 |
Lean.Meta.Grind.Extension.addEMatchAttrAndSuggest | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.Extension →
Lean.Syntax →
Lean.Name →
Lean.AttributeKind → Lean.Meta.Grind.SymbolPriorities → Bool → Bool → optParam Bool false → Lean.MetaM Unit |
SimpleGraph.Copy.mapNeighborSet._proof_2 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_2} {β : Type u_1} {A : SimpleGraph α} {B : SimpleGraph β} (f : A.Copy B) (a : α) (v : ↑(A.neighborSet a)),
f.toHom ↑v ∈ B.neighborSet (f.toHom a) |
IsReduced.mk | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_5} [inst : Zero R] [inst_1 : Pow R ℕ], (∀ (x : R), IsNilpotent x → x = 0) → IsReduced R |
ArchimedeanOrder.instLE | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} → [AddGroup M] → [Lattice M] → LE (ArchimedeanOrder M) |
Plausible.TestResult.ctorElim | Plausible.Testable | {p : Prop} →
{motive : Plausible.TestResult p → Sort u} →
(ctorIdx : ℕ) →
(t : Plausible.TestResult p) → ctorIdx = t.ctorIdx → Plausible.TestResult.ctorElimType ctorIdx → motive t |
CategoryTheory.ComposableArrows.sc'._auto_5 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax |
Lean.Meta.StructProjDecl.projName | Lean.Meta.Structure | Lean.Meta.StructProjDecl → Lean.Name |
HomologicalComplex.evalCompCoyonedaCorepresentableBySingle._proof_3 | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_3 : DecidableEq ι]
(hi : ∀ (j : ι), ¬c.Rel i j) (X : C) {K : HomologicalComplex C c}
(f : ((HomologicalComplex.eval C c i).comp (CategoryTheory.coyoneda.obj (Opposite.op X))).obj K),
(fun g => CategoryTheory.CategoryStruct.comp (HomologicalComplex.singleObjXSelf c i X).inv (g.f i))
((fun f => HomologicalComplex.mkHomFromSingle f ⋯) f) =
f |
WithBot.ofDual_lt_ofDual_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] {x y : WithBot αᵒᵈ}, WithBot.ofDual x < WithBot.ofDual y ↔ y < x |
_private.Mathlib.RingTheory.Perfectoid.BDeRham.0.«_aux_Mathlib_RingTheory_Perfectoid_BDeRham___macroRules__private_Mathlib_RingTheory_Perfectoid_BDeRham_0_term𝔹_dR^+(_)_1» | Mathlib.RingTheory.Perfectoid.BDeRham | Lean.Macro |
Matrix.det_isEmpty | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] [IsEmpty n]
{A : Matrix n n R}, A.det = 1 |
Lean.JsonRpc.RequestID.num.inj | Lean.Data.JsonRpc | ∀ {n n_1 : Lean.JsonNumber}, Lean.JsonRpc.RequestID.num n = Lean.JsonRpc.RequestID.num n_1 → n = n_1 |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.castArgsIfNeededAux.match_3 | Lean.Compiler.LCNF.ExplicitBoxing | (motive :
MProd (Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.impure))
(Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure)) →
Sort u_1) →
(r :
MProd (Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.impure))
(Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure))) →
((casters : Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.impure)) →
(newArgs : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure)) → motive ⟨casters, newArgs⟩) →
motive r |
Vector.rec | Init.Data.Vector.Basic | {α : Type u} →
{n : ℕ} →
{motive : Vector α n → Sort u_1} →
((toArray : Array α) → (size_toArray : toArray.size = n) → motive (Vector.mk toArray size_toArray)) →
(t : Vector α n) → motive t |
Std.TreeMap.mem_of_mem_union_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₁ ∪ t₂ → k ∉ t₂ → k ∈ t₁ |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.tdiv_one.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x |
_private.Lean.Meta.GeneralizeTelescope.0.Lean.Meta.GeneralizeTelescope.generalizeTelescopeAux.match_1 | Lean.Meta.GeneralizeTelescope | (motive : Lean.LocalDecl → Sort u_1) →
(localDecl : Lean.LocalDecl) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) → motive (Lean.LocalDecl.cdecl index fvarId userName type bi kind)) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type value : Lean.Expr) →
(nondep : Bool) →
(kind : Lean.LocalDeclKind) →
motive (Lean.LocalDecl.ldecl index fvarId userName type value nondep kind)) →
motive localDecl |
TensorProduct.finsuppLeft_symm_apply_single | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {M : Type u_3}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] {ι : Type u_5} [inst_9 : DecidableEq ι] (i : ι) (m : M) (n : N),
((TensorProduct.finsuppLeft R S M N ι).symm fun₀ | i => m ⊗ₜ[R] n) = (fun₀ | i => m) ⊗ₜ[R] n |
CategoryTheory.SpectralSequence.Hom.mk.injEq | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Abelian C] {κ : Type u_2}
{c : ℤ → ComplexShape κ} {r₀ : ℤ} {E E' : CategoryTheory.SpectralSequence C c r₀}
(hom : (r : ℤ) → (hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_1) → E.page r ⋯ ⟶ E'.page r ⋯)
(comm :
autoParam
(∀ (r r' : ℤ) (pq : κ) (hrr' : autoParam (r + 1 = r') CategoryTheory.SpectralSequence.Hom._auto_5)
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_7),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap (hom r ⋯) pq) (E'.iso r r' pq ⋯ ⋯).hom =
CategoryTheory.CategoryStruct.comp (E.iso r r' pq ⋯ ⋯).hom ((hom r' ⋯).f pq))
CategoryTheory.SpectralSequence.Hom.comm._autoParam)
(hom_1 : (r : ℤ) → (hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_1) → E.page r ⋯ ⟶ E'.page r ⋯)
(comm_1 :
autoParam
(∀ (r r' : ℤ) (pq : κ) (hrr' : autoParam (r + 1 = r') CategoryTheory.SpectralSequence.Hom._auto_5)
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.Hom._auto_7),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.homologyMap (hom_1 r ⋯) pq) (E'.iso r r' pq ⋯ ⋯).hom =
CategoryTheory.CategoryStruct.comp (E.iso r r' pq ⋯ ⋯).hom ((hom_1 r' ⋯).f pq))
CategoryTheory.SpectralSequence.Hom.comm._autoParam),
({ hom := hom, comm := comm } = { hom := hom_1, comm := comm_1 }) = (hom = hom_1) |
CategoryTheory.EnrichedCat.bicategory._proof_6 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b : CategoryTheory.EnrichedCat V} {f g : CategoryTheory.EnrichedFunctor V ↑a ↑b} (η : f ⟶ g),
CategoryTheory.EnrichedCat.whiskerLeft (CategoryTheory.EnrichedFunctor.id V ↑a) η =
CategoryTheory.CategoryStruct.comp (CategoryTheory.EnrichedCat.leftUnitor f).hom
(CategoryTheory.CategoryStruct.comp η (CategoryTheory.EnrichedCat.leftUnitor g).inv) |
OpenSubgroup.hasCoeSubgroup.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
OpenSubgroup.hasCoeSubgroup = { coe := OpenSubgroup.toSubgroup } |
UniqueAdd.mt | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} [inst : Add G] {A B : Finset G} {a0 b0 : G},
UniqueAdd A B a0 b0 → ∀ ⦃a b : G⦄, a ∈ A → b ∈ B → a ≠ a0 ∨ b ≠ b0 → a + b ≠ a0 + b0 |
Batteries.RBColor.black.elim | Batteries.Data.RBMap.Basic | {motive : Batteries.RBColor → Sort u} →
(t : Batteries.RBColor) → t.ctorIdx = 1 → motive Batteries.RBColor.black → motive t |
HomologicalComplex.Hom.comm | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {A B : HomologicalComplex V c} (f : A.Hom B)
(i j : ι), CategoryTheory.CategoryStruct.comp (f.f i) (B.d i j) = CategoryTheory.CategoryStruct.comp (A.d i j) (f.f j) |
PiTensorProduct.constantBaseRingEquiv_symm | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_3} [inst : CommSemiring R] [inst_1 : Fintype ι] (r : R),
(PiTensorProduct.constantBaseRingEquiv ι R).symm r = (algebraMap R (PiTensorProduct R fun x => R)) r |
Plausible.Shrinkable.shrink | Plausible.Sampleable | {α : Type u} → [self : Plausible.Shrinkable α] → α → List α |
AddSubgroup.comap_map_eq | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
AddSubgroup.comap f (AddSubgroup.map f H) = H ⊔ f.ker |
instNonUnitalCStarAlgebraForall._proof_1 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {ι : Type u_2} {A : ι → Type u_1} [inst : (i : ι) → NonUnitalCStarAlgebra (A i)], CompleteSpace ((i : ι) → A i) |
_aux_Mathlib_Algebra_Group_Hom_Defs___unexpand_MonoidHom_1 | Mathlib.Algebra.Group.Hom.Defs | Lean.PrettyPrinter.Unexpander |
WithBot.bot_mul_bot | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α], ⊥ * ⊥ = ⊥ |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Basic.0.IntermediateField.adjoin_simple_isCompactElement._simp_1_2 | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {α : E}
{K : IntermediateField F E}, (F⟮α⟯ ≤ K) = (α ∈ K) |
_private.Mathlib.Data.Multiset.Filter.0.Multiset.filter_attach'._simp_1_2 | Mathlib.Data.Multiset.Filter | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) |
Finsupp.DegLex.single_antitone | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} [inst : LinearOrder α], Antitone fun a => toDegLex fun₀ | a => 1 |
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.instPreservesFiniteBiproductsTensorLeft._simp_3 | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f |
_private.Batteries.Data.Array.Monadic.0.cond.match_1.splitter | Batteries.Data.Array.Monadic | (motive : Bool → Sort u_1) → (c : Bool) → (Unit → motive true) → (Unit → motive false) → motive c |
Module.FaithfullyFlat.subsingleton_tensorProduct_iff_right | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] [Module.FaithfullyFlat R M],
Subsingleton (TensorProduct R M N) ↔ Subsingleton N |
Lean.Doc.State.openDecls | Lean.Elab.DocString | Lean.Doc.State → List Lean.OpenDecl |
aeSeq.measurable | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : ι → α → β}
{μ : MeasureTheory.Measure α} (hf : ∀ (i : ι), AEMeasurable (f i) μ) (p : α → (ι → β) → Prop) (i : ι),
Measurable (aeSeq hf p i) |
Function.argmin._proof_1 | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [WellFoundedLT β],
WellFounded (InvImage (fun x1 x2 => x1 < x2) f) |
Finset.le_card_mul_mul_mulEnergy | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Mul α] (s t : Finset α),
s.card ^ 2 * t.card ^ 2 ≤ (s * t).card * s.mulEnergy t |
chartAt | Mathlib.Geometry.Manifold.ChartedSpace | (H : Type u_5) →
[inst : TopologicalSpace H] →
{M : Type u_6} → [inst_1 : TopologicalSpace M] → [ChartedSpace H M] → M → OpenPartialHomeomorph M H |
RestrictedProduct.instMonoidCoeOfSubmonoidClass._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_3} (R : ι → Type u_2) {S : ι → Type u_1} [inst : (i : ι) → SetLike (S i) (R i)]
[inst_1 : (i : ι) → Monoid (R i)] [∀ (i : ι), SubmonoidClass (S i) (R i)] (i : ι), MulMemClass (S i) (R i) |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.FiniteMeasure.limsup_measure_closed_le_of_tendsto._simp_1_1 | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True |
AddUnits.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : AddMonoid M]
[inst_3 : AddAction M X] [ContinuousVAdd M X], ContinuousVAdd (AddUnits M) X |
FixedDetMatrices.instMulActionSpecialLinearGroupFixedDetMatrix._proof_3 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ (n : Type u_1) [inst : DecidableEq n] [inst_1 : Fintype n] (R : Type u_2) [inst_2 : CommRing R] (m : R)
(b : FixedDetMatrix n R m), 1 • b = b |
Lean.Elab.CheckTactic.elabCheckTactic | Lean.Elab.CheckTactic | Lean.Elab.Command.CommandElab |
Subring.toAddSubgroup_strictMono | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : Ring R], StrictMono Subring.toAddSubgroup |
MeasureTheory.SimpleFunc.pow_apply | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Monoid β] (n : ℕ)
(f : MeasureTheory.SimpleFunc α β) (a : α), (f ^ n) a = f a ^ n |
continuousSMul_closedBall_ball | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ}, ContinuousSMul ↑(Metric.closedBall 0 1) ↑(Metric.ball 0 r) |
Set.sUnion_sub | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} [inst : Sub α] (S : Set (Set α)) (t : Set α), ⋃₀ S - t = ⋃ s ∈ S, s - t |
BitVec.getMsbD_rotateLeft | Init.Data.BitVec.Lemmas | ∀ {r n w : ℕ} {x : BitVec w}, (x.rotateLeft r).getMsbD n = (decide (n < w) && x.getMsbD ((r + n) % w)) |
CommSemiRingCat.Hom.hom | Mathlib.Algebra.Category.Ring.Basic | {R S : CommSemiRingCat} → R.Hom S → ↑R →+* ↑S |
Submodule.Quotient.equiv._proof_1 | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : Submodule R M) (Q : Submodule R N) (f : M ≃ₗ[R] N),
Submodule.map (↑f) P = Q → ∀ x ∈ Q, x ∈ Submodule.comap (↑f.symm) P |
CategoryTheory.Limits.createsFiniteLimitsOfCreatesFiniteLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
((J : Type w) →
{x : CategoryTheory.SmallCategory J} →
CategoryTheory.FinCategory J → CategoryTheory.CreatesLimitsOfShape J F) →
CategoryTheory.Limits.CreatesFiniteLimits F |
CategoryTheory.Equivalence.enoughProjectives_iff | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : C ≌ D), CategoryTheory.EnoughProjectives C ↔ CategoryTheory.EnoughProjectives D |
_private.Mathlib.CategoryTheory.Shift.ShiftedHomOpposite.0.CategoryTheory.ShiftedHom.opEquiv_symm_comp._proof_1 | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | ∀ {a b c : ℤ}, b + a = c → a + b = c |
Nat.getElem_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ} (_h : i < (m<...=n).toArray.size), (m<...=n).toArray[i] = m + 1 + i |
Lean.Compiler.LCNF.instInhabitedSpecEntry | Lean.Compiler.LCNF.SpecInfo | Inhabited Lean.Compiler.LCNF.SpecEntry |
_private.Mathlib.GroupTheory.DivisibleHull.0.«term↑ⁿ» | Mathlib.GroupTheory.DivisibleHull | Lean.ParserDescr |
Left.one_lt_mul | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftStrictMono α] {a b : α}, 1 < a → 1 < b → 1 < a * b |
_private.Init.Data.String.Basic.0.String.Slice.Pos.next_eq_nextFast._proof_1_7 | Init.Data.String.Basic | ∀ (s : String.Slice) (pos : s.Pos) (h : pos ≠ s.endPos),
¬pos.offset.byteIdx + (pos.str.get ⋯).utf8Size =
s.startInclusive.offset.byteIdx + pos.offset.byteIdx + (pos.str.get ⋯).utf8Size -
s.startInclusive.offset.byteIdx →
False |
NormedField.toNormedSpace._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] (a b : 𝕜), ‖a * b‖ ≤ ‖a‖ * ‖b‖ |
USize.ofNatLT_sub | Init.Data.UInt.Lemmas | ∀ {a b : ℕ} (ha : a < 2 ^ System.Platform.numBits) (hab : b ≤ a),
USize.ofNatLT (a - b) ⋯ = USize.ofNatLT a ha - USize.ofNatLT b ⋯ |
SimpleGraph.Subgraph.instDecidableRel_deleteVerts_adj._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (u : Set V) (x : ↑(⊤.deleteVerts u).verts), ↑x ∈ ⊤.verts |
Lean.Grind.AC.SubseqResult.false.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Seq | sizeOf Lean.Grind.AC.SubseqResult.false = 1 |
Homotopy.compLeft | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D E : HomologicalComplex V c} →
{f g : D ⟶ E} →
Homotopy f g →
(e : C ⟶ D) → Homotopy (CategoryTheory.CategoryStruct.comp e f) (CategoryTheory.CategoryStruct.comp e g) |
Sym2.inf | Mathlib.Data.Sym.Sym2.Order | {α : Type u_1} → [SemilatticeInf α] → Sym2 α → α |
Aesop.RuleTerm.const.elim | Aesop.RuleTac.RuleTerm | {motive : Aesop.RuleTerm → Sort u} →
(t : Aesop.RuleTerm) → t.ctorIdx = 0 → ((decl : Lean.Name) → motive (Aesop.RuleTerm.const decl)) → motive t |
Algebra.SubmersivePresentation.jacobianRelationsOfHasCoeffs._proof_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_2} {S : Type u_4} {ι : Type u_1} {σ : Type u_5} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (R₀ : Type u_3)
[inst_4 : CommRing R₀] [inst_5 : Algebra R₀ R] [inst_6 : Algebra R₀ S] [inst_7 : IsScalarTower R₀ R S]
[P.HasCoeffs R₀] (i : σ), P.jacobianRelations i ∈ Set.range ⇑(MvPolynomial.map (algebraMap R₀ R)) |
Std.DHashMap.Internal.Raw₀.getKey?_insert_self | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k : α} {v : β k}, (m.insert k v).getKey? k = some k |
Lean.Elab.Attribute.stx | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.Syntax |
CategoryTheory.Functor.splitEpiEquiv._proof_6 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {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] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[inst_2 : F.Full] [inst_3 : F.Faithful] (x : CategoryTheory.SplitEpi (F.map f)),
(fun f_1 => f_1.map F) ((fun s => { section_ := F.preimage s.section_, id := ⋯ }) x) = x |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.SFinite.0.MeasureTheory.Measure.countable_meas_pos_of_disjoint_iUnion₀._simp_1_4 | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (a ≤ 0) = (a = 0) |
_private.Init.TacticsExtra.0.Lean.Parser.Tactic._aux_Init_TacticsExtra___macroRules_Lean_Parser_Tactic_tacticRw_mod_cast____1.match_1 | Init.TacticsExtra | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc |
Cardinal.add_one_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}}, α + 1 = β + 1 ↔ α = β |
PowerSeries.IsWeierstrassDivision.unique | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] [inst_1 : IsLocalRing A] {f g : PowerSeries A},
(PowerSeries.map (IsLocalRing.residue A)) g ≠ 0 →
∀ [inst_2 : IsAdicComplete (IsLocalRing.maximalIdeal A) A] {q : PowerSeries A} {r : Polynomial A},
f.IsWeierstrassDivision g q r → q = f /ʷ g ∧ r = f %ʷ g |
Ideal.add_eq_sup | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I J : Ideal R}, I + J = I ⊔ J |
_private.Mathlib.LinearAlgebra.TensorProduct.Map.0.LinearMap.rTensor_neg._simp_1_1 | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], LinearMap.rTensor M = ⇑(LinearMap.rTensorHom M) |
IsRightRegular.mul_right_eq_self_iff | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Monoid R] {a b : R}, IsRightRegular a → (b * a = a ↔ b = 1) |
StrictAnti.strictAntiOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
StrictAnti f → ∀ (s : Set α), StrictAntiOn f s |
NonUnitalStarRingHom.copy._proof_2 | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_2} {B : Type u_1} [inst : NonUnitalNonAssocSemiring A] [inst_1 : Star A]
[inst_2 : NonUnitalNonAssocSemiring B] [inst_3 : Star B] (f : A →⋆ₙ+* B) (f' : A → B), f' = ⇑f → f' 0 = 0 |
Lean.Elab.FixedParams.instToFormatInfo | Lean.Elab.PreDefinition.FixedParams | Std.ToFormat Lean.Elab.FixedParams.Info |
BitVec.ushiftRight_eq_extractLsb'_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ} (hn : n < w), x >>> n = BitVec.cast ⋯ (0#n ++ BitVec.extractLsb' n (w - n) x) |
HomologicalComplex.leftUnitor'_inv_comm_assoc | Mathlib.Algebra.Homology.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Limits.HasZeroObject C]
[inst_4 : (CategoryTheory.MonoidalCategory.curriedTensor C).Additive]
[inst_5 : ∀ (X₁ : C), ((CategoryTheory.MonoidalCategory.curriedTensor C).obj X₁).Additive] {I : Type u_2}
[inst_6 : AddMonoid I] {c : ComplexShape I} [inst_7 : c.TensorSigns] (K : HomologicalComplex C c)
[inst_8 : DecidableEq I]
[inst_9 :
∀ (X₂ : C),
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C)
((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj X₂)]
(i j : I) {Z : C} (h : ((HomologicalComplex.tensorUnit C c).tensorObj K).X j ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.leftUnitor'.inv i)
(CategoryTheory.CategoryStruct.comp (((HomologicalComplex.tensorUnit C c).tensorObj K).d i j) h) =
CategoryTheory.CategoryStruct.comp (K.d i j) (CategoryTheory.CategoryStruct.comp (K.leftUnitor'.inv j) h) |
FirstOrder.Field.FieldAxiom.toProp | Mathlib.ModelTheory.Algebra.Field.Basic | (K : Type u_2) → [Add K] → [Mul K] → [Neg K] → [Zero K] → [One K] → FirstOrder.Field.FieldAxiom → Prop |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.equiv_zero_of_val_eq_of_equiv_zero.match_1_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {f : PadicSeq p} (ε : ℚ)
(motive : (∃ i, ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε) → Prop) (x : ∃ i, ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε),
(∀ (i : ℕ) (hi : ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε), motive ⋯) → motive x |
ProbabilityTheory.Kernel.isProper_iff_inter_eq_indicator_mul | Mathlib.Probability.Kernel.Proper | ∀ {X : Type u_1} {𝓑 𝓧 : MeasurableSpace X} {π : ProbabilityTheory.Kernel X X},
𝓑 ≤ 𝓧 →
(π.IsProper ↔
∀ ⦃A : Set X⦄,
MeasurableSet A → ∀ ⦃B : Set X⦄, MeasurableSet B → ∀ (x : X), (π x) (A ∩ B) = B.indicator 1 x * (π x) A) |
Std.Net.instDecidableEqIPv6Addr.decEq | Std.Net.Addr | (x x_1 : Std.Net.IPv6Addr) → Decidable (x = x_1) |
IsCancelSMul.toIsLeftCancelSMul | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} {inst : SMul G P} [self : IsCancelSMul G P], IsLeftCancelSMul G P |
«_aux_Init_Notation___macroRules_term_∘__1» | Init.Notation | Lean.Macro |
DFinsupp.comapDomain'.congr_simp | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) {h' h'_1 : ι → κ}
(e_h' : h' = h'_1) (hh' : Function.LeftInverse h' h) (f f_1 : Π₀ (i : ι), β i),
f = f_1 → DFinsupp.comapDomain' h hh' f = DFinsupp.comapDomain' h ⋯ f_1 |
VectorField.mlieBracketWithin_congr_set | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s t : Set M} {x : M} {V W : (x : M) → TangentSpace I x},
s =ᶠ[nhds x] t → VectorField.mlieBracketWithin I V W s x = VectorField.mlieBracketWithin I V W t x |
Representation.isTrivial_def | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) [ρ.IsTrivial] (g : G), ρ g = LinearMap.id |
Lean.Kernel.Environment.addDeclWithoutChecking | Lean.Environment | Lean.Kernel.Environment → Lean.Declaration → Except Lean.Kernel.Exception Lean.Kernel.Environment |
CategoryTheory.isNoetherianObject_iff_isEventuallyConstant | Mathlib.CategoryTheory.Subobject.NoetherianObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.IsNoetherianObject X ↔
∀ (F : CategoryTheory.Functor ℕ (CategoryTheory.MonoOver X)), CategoryTheory.IsFiltered.IsEventuallyConstant F |
_private.Lean.Shell.0.Lean.ShellOptions.process.liftIO | Lean.Shell | {α : Type} → IO α → EIO UInt32 α |
MulAction.is_one_preprimitive_iff | Mathlib.GroupTheory.GroupAction.MultiplePrimitivity | ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α],
MulAction.IsMultiplyPreprimitive M α 1 ↔ MulAction.IsPreprimitive M α |
CategoryTheory.Functor.leftKanExtensionIsoFiberwiseColimit._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_2} {D : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_6} D] (L : CategoryTheory.Functor C D) {H : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} H] (F : CategoryTheory.Functor C H) [L.HasPointwiseLeftKanExtension F]
(X : D),
CategoryTheory.Limits.HasColimit
((CategoryTheory.Grothendieck.ι (CategoryTheory.CostructuredArrow.functor L) X).comp
((CategoryTheory.CostructuredArrow.grothendieckProj L).comp F)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.