name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LowerAdjoint.instInhabitedId | Mathlib.Order.Closure | {α : Type u_1} → [inst : Preorder α] → Inhabited (LowerAdjoint id) | null | true |
FirstOrder.Language.Substructure.casesOn | Mathlib.ModelTheory.Substructures | {L : FirstOrder.Language} →
{M : Type w} →
[inst : L.Structure M] →
{motive : L.Substructure M → Sort u_1} →
(t : L.Substructure M) →
((carrier : Set M) →
(fun_mem : ∀ {n : ℕ} (f : L.Functions n), FirstOrder.Language.ClosedUnder f carrier) →
motive { carrier :... | null | false |
_private.Mathlib.RingTheory.Polynomial.IsIntegral.0.IsIntegral.coeff._simp_1_7 | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
CategoryTheory.HasExactColimitsOfShape.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {J : Type u'} →
[inst : CategoryTheory.Category.{v', u'} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasColimitsOfShape J C] →
{motive : CategoryTheory.HasExactColimitsOfShape J C → Sort u_1} →
((preservesFiniteLimits : Cate... | null | false |
NNReal.toReal_le | Mathlib.Data.NNReal.Basic | ∀ (a b : NNReal), a ≤ b ↔ ↑a ≤ ↑b | null | true |
CategoryTheory.Functor.IsRightDerivedFunctor.isLeftKanExtension | Mathlib.CategoryTheory.Functor.Derived.RightDerived | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_3} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_3, u_2} D} {inst_2 : CategoryTheory.Category.{v_5, u_3} H}
(RF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : F ⟶ L.comp RF) (W : ... | null | true |
BitVec.toNat_lt_iff_getLsbD_eq_false | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, ∀ i < w, x.toNat < 2 ^ i ↔ ∀ (k : ℕ), x.getLsbD (i + k) = false | A bitvector interpreted as a natural number is strictly smaller than `2 ^ i` if and only if
all bits at position `i` or higher are false. | true |
Representation.Coinvariants.le_comap_ker | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (S : Subgroup G) [S.Normal] (g : G),
Representation.Coinvariants.ker (MonoidHom.comp ρ S.subtype) ≤
Submodule.comap (ρ g) (Representation.Coinvariants.... | null | true |
List.getElem_concat_length | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {a : α} {i : ℕ}, i = l.length → ∀ (w : i < (l ++ [a]).length), (l ++ [a])[i] = a | null | true |
ModuleCat.smulShortComplex_X₂_carrier | Mathlib.RingTheory.Regular.Category | ∀ {R : Type u} [inst : CommRing R] (M : ModuleCat R) (r : R), ↑(M.smulShortComplex r).X₂ = ↑M | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.Mathlib.Meta.Positivity.evalENNRealRpow.match_13 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | (α : Q(Type)) →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(a : Q(«$α»)) →
(b : Q(ℝ)) →
(motive :
Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) a →
Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) b → Sort u_... | null | false |
instHashableFin | Init.Data.Hashable | {n : ℕ} → Hashable (Fin n) | null | true |
Std.ExtDTreeMap.Const.maxKey_modify | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : β → β} {he : Std.ExtDTreeMap.Const.modify t k f ≠ ∅},
(Std.ExtDTreeMap.Const.modify t k f).maxKey he = if cmp (t.maxKey ⋯) k = Ordering.eq then k else t.maxKey ⋯ | null | true |
MulEquiv.withOneCongr_refl | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} [inst : Mul α], (MulEquiv.refl α).withOneCongr = MulEquiv.refl (WithOne α) | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.Plus.0.HomotopyCategory.instIsStableUnderShiftIntUpPlus._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ (n q : ℤ), n + (q - n) = q | null | false |
AlgebraicGeometry.Spec.sheafedSpaceMap._proof_1 | Mathlib.AlgebraicGeometry.Spec | ∀ {R S : CommRingCat} (f : R ⟶ S)
{x x_1 : (TopologicalSpace.Opens ↑↑(AlgebraicGeometry.Spec.sheafedSpaceObj R).toPresheafedSpace)ᵒᵖ} (x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.Spec.sheafedSpaceObj R).presheaf.map x_2)
(CommRingCat.ofHom
(AlgebraicGeometry.StructureSheaf.c... | null | false |
ArithmeticFunction.one_smul' | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : ArithmeticFunction M), 1 • b = b | null | true |
DFinsupp.addZeroClass._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddZeroClass (β i)], Function.Injective DFunLike.coe | null | false |
UInt32.ofFin_rev | Init.Data.UInt.Bitwise | ∀ (a : Fin UInt32.size), UInt32.ofFin a.rev = ~~~UInt32.ofFin a | null | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trStmts₁_trans._simp_1_10 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
Option.getD_eq_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {a b : α}, o.getD a = b ↔ o = some b ∨ o = none ∧ a = b | null | true |
CategoryTheory.SpectralSequence.pageXIsoOfEq._auto_1 | Mathlib.Algebra.Homology.SpectralSequence.Basic | Lean.Syntax | null | false |
_private.Init.Data.Vector.OfFn.0.Vector.ofFnM_go_succ._proof_7 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {i : ℕ} {xs : Array α} {n : ℕ},
autoParam (i ≤ n) Vector.ofFnM_go_succ._auto_5✝ → ∀ {h : xs.size = i}, ¬i ≤ n + 1 → False | null | false |
Aesop.Check.mk._flat_ctor | Aesop.Check | Lean.Option Bool → Aesop.Check | null | false |
Array.mem_of_getElem? | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α}, xs[i]? = some a → a ∈ xs | null | true |
Matrix.specialUnitaryGroup.coe_star | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : ↥(Matrix.specialUnitaryGroup n α)), ↑(star A) = star ↑A | null | true |
Algebra.isAlgebraic_adjoin_iff | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDomain R]
{s : Set S}, (Algebra.adjoin R s).IsAlgebraic ↔ ∀ x ∈ s, IsAlgebraic R x | null | true |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.succ_nth_conv_eq_squashGCF_nth_conv._proof_1_5 | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {g : GenContFract K} [inst : Field K] (a b : K),
b ≠ 0 →
∀ (n' : ℕ) (pa pb : K),
((pb + a / b) * (g.contsAux (n' + 1)).a + pa * (g.contsAux n').a) /
((pb + a / b) * (g.contsAux (n' + 1)).b + pa * (g.contsAux n').b) =
(b * (pb * (g.contsAux (n' + 1)).a + pa * (g.contsAux n'... | null | false |
ContinuousOrderHom.instFunLike._proof_1 | Mathlib.Topology.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : TopologicalSpace β]
[inst_3 : Preorder β] (f g : α →Co β), (fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
_private.Mathlib.GroupTheory.QuotientGroup.Defs.0.QuotientGroup.mk'_eq_mk'._simp_1_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (b * a = c) = (a = b⁻¹ * c) | null | false |
Rep.FiniteCyclicGroup.coinvariantsTensorResolutionIso._proof_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G],
CategoryTheory.Limits.HasZeroObject (Rep.{u_1, u_1, u_1} k G) | null | false |
Lean.Grind.CommRing.Expr.toPolyS.match_4.congr_eq_3 | Init.Grind.Ring.CommSemiringAdapter | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Expr)
(h_1 : (n : ℤ) → motive (Lean.Grind.CommRing.Expr.num n))
(h_2 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_3 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_4 : (a b : Lean.Grind.CommRing.... | null | true |
PartitionOfUnity.mem_finsupport | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (ρ : PartitionOfUnity ι X s) (x₀ : X) {i : ι},
i ∈ ρ.finsupport x₀ ↔ i ∈ Function.support fun i => (ρ i) x₀ | null | true |
WittVector.IsocrystalHom._sizeOf_inst | Mathlib.RingTheory.WittVector.Isocrystal | (p : ℕ) →
{inst : Fact (Nat.Prime p)} →
(k : Type u_1) →
{inst_1 : CommRing k} →
{inst_2 : CharP k p} →
{inst_3 : PerfectRing k p} →
(V : Type u_2) →
{inst_4 : AddCommGroup V} →
{inst_5 : WittVector.Isocrystal p k V} →
(V₂ : Type ... | null | false |
Lean.Sym.decide_isFalse_congr | Init.Sym.Lemmas | ∀ (p p' : Prop), p = p' → ∀ {inst : Decidable p} {hnp : ¬p'}, decide p = false | null | true |
UInt64.ofFin_bitVecToFin | Init.Data.UInt.Lemmas | ∀ (n : BitVec 64), UInt64.ofFin n.toFin = { toBitVec := n } | null | true |
_private.Init.Grind.Ordered.Ring.0.Lean.Grind.OrderedRing.pos_intCast_of_pos._proof_1_1 | Init.Grind.Ordered.Ring | ∀ (a : ℕ), 0 < Int.negSucc a → False | null | false |
NormedAddGroupHom.ext | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
{f g : NormedAddGroupHom V₁ V₂}, (∀ (x : V₁), f x = g x) → f = g | null | true |
Set.Icc_subset_Icc_iff | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α}, a₁ ≤ b₁ → (Set.Icc a₁ b₁ ⊆ Set.Icc a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂) | null | true |
AlgebraicGeometry.IsAffineOpen.isLocalization_stalk | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U) (x : ↥U),
IsLocalization.AtPrime (↑(X.presheaf.stalk ↑x)) (hU.primeIdealOf x).asIdeal | null | true |
Lean.Literal.natVal.sizeOf_spec | Lean.Expr | ∀ (val : ℕ), sizeOf (Lean.Literal.natVal val) = 1 + sizeOf val | null | true |
AddSubgroup.fintypeOfIndexNeZero.eq_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} (hH : H.index ≠ 0),
AddSubgroup.fintypeOfIndexNeZero hH = Fintype.ofFinite (G ⧸ H) | null | true |
List.lookmap_congr | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} {f g : α → Option α} {l : List α}, (∀ a ∈ l, f a = g a) → List.lookmap f l = List.lookmap g l | null | true |
Lean.Elab.Tactic.Conv.evalReduce | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.Tactic | null | true |
_aux_Mathlib_Analysis_Normed_Affine_Isometry___unexpand_AffineIsometryEquiv_1 | Mathlib.Analysis.Normed.Affine.Isometry | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.coeff_prod_mem_ideal_pow_tsub._proof_1_3 | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {ι : Type u_2} (f : ι → Polynomial R) (I : Ideal R) (n : ι → ℕ) (a : ι)
(s : Finset ι),
((∀ i ∈ s, ∀ (k : ℕ), (f i).coeff k ∈ I ^ (n i - k)) → ∀ (k : ℕ), (s.prod f).coeff k ∈ I ^ (s.sum n - k)) →
(∀ i ∈ insert a s, ∀ (k : ℕ), (f i).coeff k ∈ I ^ (n i - k)) →
∀ (i j... | null | false |
List.mem_eraseDups._simp_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, (a ∈ l.eraseDups) = (a ∈ l) | null | false |
Int.inductionOn'.pos.match_1.congr_eq_2 | Mathlib.Data.Int.Init | ∀ (motive : ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ) (n : ℕ),
x = n.succ →
(match x with
| 0 => h_1 ()
| n.succ => h_2 n) ≍
h_2 n | null | true |
Lean.Grind.Linarith.Poly.denoteN.match_1 | Init.Grind.Module.NatModuleNorm | (motive : Lean.Grind.Linarith.Poly → Sort u_1) →
(p : Lean.Grind.Linarith.Poly) →
(Unit → motive Lean.Grind.Linarith.Poly.nil) →
((k : ℤ) →
(v : Lean.Grind.Linarith.Var) →
(p : Lean.Grind.Linarith.Poly) → motive (Lean.Grind.Linarith.Poly.add k v p)) →
motive p | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.withExistingLocalDeclsImp | Lean.Meta.Basic | {α : Type} → List Lean.LocalDecl → Lean.MetaM α → Lean.MetaM α | null | true |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.mk | Mathlib.AlgebraicGeometry.AffineTransitionLimit | {I : Type u} →
[inst : CategoryTheory.Category.{u, u} I] →
{S X : AlgebraicGeometry.Scheme} →
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} →
{t : D ⟶ (CategoryTheory.Functor.const I).obj S} →
{f : X ⟶ S} →
(c : CategoryTheory.Limits.Cone D) →
CategoryTh... | null | true |
Module.End.smulLeft._proof_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
∀ α ∈ Set.center R, ∀ (β : R) (x : M), α • β • x = (RingHom.id R) β • α • x | null | false |
Array.ne_of_not_mem_push | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a b : α} {xs : Array α}, a ∉ xs.push b → a ≠ b | null | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Frontend.0.Lean.Elab.Tactic.Do.Internal.ParsedArgs.mk._flat_ctor | Lean.Elab.Tactic.Do.Internal.VCGen.Frontend | Lean.Elab.Tactic.Do.VCGen.Config →
Lean.Elab.Tactic.Do.Internal.VCGen.Context →
Lean.Meta.Grind.Params → Option (Std.HashMap ℕ Lean.Syntax) → Lean.Elab.Tactic.Do.Internal.ParsedArgs✝ | null | false |
CochainComplex.HomComplex.Cochain.rightShift.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ γ_1 : CochainComplex.HomComplex.Cochain K L n),
γ = γ_1 →
∀ (a n' : ℤ) (hn' : n' + a = n) (T : CochainComplex.HomComplex.Triplet n'),
γ.rightShift a n' hn' T = γ_1.rightSh... | null | true |
Lean.Language.SnapshotTask.cancelRec._unsafe_rec | Lean.Language.Basic | {α : Type} → [Lean.Language.ToSnapshotTree α] → Lean.Language.SnapshotTask α → BaseIO Unit | null | false |
CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono'_p | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.RightHomologyData) [inst_2 : CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
(Category... | null | true |
_private.Mathlib.Order.KrullDimension.0.Order.height_eq_coe_iff_minimal_le_height._simp_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_2} {P : α → Prop} {x : α} [inst : Preorder α], Minimal P x = (P x ∧ ∀ ⦃y : α⦄, y < x → ¬P y) | null | false |
CategoryTheory.Functor.splitMonoBiprodComparison'_retraction | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) (X Y : C) [inst_4 : CategoryTheory.Limits.HasBinaryBiproduc... | null | true |
Std.DTreeMap.Const.foldr_eq_foldr_toArray | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {δ : Type w} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp}
{f : α → β → δ → δ} {init : δ},
Std.DTreeMap.foldr f init t = Array.foldr (fun a b => f a.1 a.2 b) init (Std.DTreeMap.Const.toArray t) | null | true |
Monoid.CoprodI.Word.cons | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{M : ι → Type u_2} →
[inst : (i : ι) → Monoid (M i)] →
{i : ι} → (m : M i) → (w : Monoid.CoprodI.Word M) → w.fstIdx ≠ some i → m ≠ 1 → Monoid.CoprodI.Word M | Construct a new `Word` without any reduction. The underlying list of
`cons m w _ _` is `⟨_, m⟩::w` | true |
HomologicalComplex.Hom.isoOfComponents._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : (i : ι) → C₁.X i ≅ C₂.X i) (i j : ι),
CategoryTheory.CategoryStruct.comp (f i).inv (C₁.d i j) =
CategoryTheory.CategorySt... | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_eq_iff_of_getLsbD_false._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ), (1 < 2 → w + 1 < 2 ^ (w + 1)) → ∀ (n : ℕ), ¬w - (n + 1) < 2 ^ (w + 1) → False | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.processOffset.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) → ((k' : ℕ) → motive (some k')) → ((x : Option ℕ) → motive x) → motive __do_lift | null | false |
IsCoveringMap.liftPath_const | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X}
(cov : IsCoveringMap p) {e : E} {x : X} (hpe : x = p e),
cov.liftPath (ContinuousMap.const (↑unitInterval) x) e hpe = ContinuousMap.const (↑unitInterval) e | null | true |
Function.Periodic.sub | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {c : α} [inst : Add α] [inst_1 : Sub β],
Function.Periodic f c → Function.Periodic g c → Function.Periodic (f - g) c | null | true |
EisensteinSeries.norm_le_tsum_norm | Mathlib.NumberTheory.ModularForms.EisensteinSeries.IsBoundedAtImInfty | ∀ (N : ℕ) (a : Fin 2 → ZMod N) (k : ℤ),
3 ≤ k → ∀ (z : UpperHalfPlane), ‖eisensteinSeries a k z‖ ≤ ∑' (x : Fin 2 → ℤ), ‖EisensteinSeries.eisSummand k x z‖ | The norm of the restricted sum is less than the full sum of the norms. | true |
CategoryTheory.leftAdjointOfStructuredArrowInitials._proof_1 | Mathlib.CategoryTheory.Adjunction.Comma | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor D C)
[inst_2 : ∀ (A : C), CategoryTheory.Limits.HasInitial (CategoryTheory.StructuredArrow A G)] (x : C) (x_1 Y' : D)
(g : x_1 ⟶ Y') (h : (⊥_ CategoryTheory.Str... | null | false |
String.Slice.PosIterator.recOn | Init.Data.String.Iterate | {s : String.Slice} →
{motive : s.PosIterator → Sort u} →
(t : s.PosIterator) → ((currPos : s.Pos) → motive { currPos := currPos }) → motive t | null | false |
GradedRing.projZeroRingHom' | Mathlib.RingTheory.GradedAlgebra.Basic | {ι : Type u_1} →
{A : Type u_3} →
{σ : Type u_4} →
[inst : Semiring A] →
[inst_1 : DecidableEq ι] →
[inst_2 : AddCommMonoid ι] →
[inst_3 : PartialOrder ι] →
[CanonicallyOrderedAdd ι] →
[inst_5 : SetLike σ A] →
[inst_6 : AddSubmono... | The ring homomorphism from `A` to `𝒜 0` sending every `a : A` to `a₀`. | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.exists_cons_of_leadingCoeff_pos._proof_1_5 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] {P : Polynomial R} (η : R),
P.eraseLead.natDegree + 1 = P.natDegree →
∀ (d : ℕ),
P.natDegree = 0 + d + 1 →
((Polynomial.X - Polynomial.C η) * P).natDegree = P.natDegree + 1 →
((Polynomial.X - Polynomial.C η) * P).nextCoeff = 0 →
Polynomial.C η *... | null | false |
SeminormedGroup.ofMulDist._proof_2 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : Norm E] [inst_1 : Group E] [inst_2 : PseudoMetricSpace E],
(∀ (x : E), ‖x‖ = dist 1 x) → (∀ (x y z : E), dist x y ≤ dist (z * x) (z * y)) → ∀ (x y : E), dist x y = ‖x⁻¹ * y‖ | null | false |
ContinuousAlternatingMap.curryLeftLI_apply | Mathlib.Analysis.Normed.Module.Alternating.Curry | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(f : E [⋀^Fin (n + 1)]→L[𝕜] F), ContinuousAlternatingMap.curryLeftLI f = f.curryLeft | null | true |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep._sizeOf_inst | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
(n : ℕ) →
(X : (k : ℕ) → k < n → (t : Type (max v w)) × (t → C)) →
[SizeOf C] → SizeOf (CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep✝ n X) | null | false |
TensorProduct.LieModule.liftLie._proof_1 | Mathlib.Algebra.Lie.TensorProduct | ∀ (R : Type u_1) [inst : CommRing R] (L : Type u_2) (M : Type u_4) (N : Type u_5) (P : Type u_3) [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingMod... | null | false |
Mathlib.Tactic.Superscript.scriptFnNoAntiquot | Mathlib.Util.Superscript | Mathlib.Tactic.Superscript.Mapping → String → Lean.Parser.ParserFn → optParam Bool true → Lean.Parser.ParserFn | The core function for super/subscript parsing. It consists of three stages:
1. Parse a run of superscripted characters, skipping whitespace and stopping when we hit a
non-superscript character.
2. Un-superscript the text and pass the body to the inner parser (usually `term`).
3. Take the resulting `Syntax` object a... | true |
Vector.tail_eq_of_zero | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {v : Vector α 0}, v.tail = #v[] | null | true |
MeasureTheory.lintegral_withDensity_eq_lintegral_mul_non_measurable | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) {f : α → ENNReal},
Measurable f →
(∀ᵐ (x : α) ∂μ, f x < ⊤) → ∀ (g : α → ENNReal), ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ | null | true |
Std.ExtHashMap.getElem_filterMap | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α} {h : k ∈ Std.ExtHashMap.filterMap f m},
(Std.ExtHashMap.filterMap f m)[k] = (f (m.getKey k ⋯) m[k]).get ⋯ | null | true |
nonUnitalSubalgebraOfNonUnitalSubring | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → NonUnitalSubring R → NonUnitalSubalgebra ℤ R | A non-unital subring is a non-unital `ℤ`-subalgebra. | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.UnicodeLinter.findBadUnicodeAux.match_1.splitter | Mathlib.Tactic.Linter.TextBased | (motive : Option Char → Sort u_1) →
(x : Option Char) → (Unit → motive none) → ((cₙ : Char) → motive (some cₙ)) → motive x | null | true |
ValuativeRel.ValueGroupWithZero.mk_eq_div | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : ValuativeRel R] (r : R) (s : ↥(ValuativeRel.posSubmonoid R)),
ValuativeRel.ValueGroupWithZero.mk r s = (ValuativeRel.valuation R) r / (ValuativeRel.valuation R) ↑s | null | true |
_private.Mathlib.NumberTheory.Pell.0.Pell.exists_of_not_isSquare._proof_1_7 | Mathlib.NumberTheory.Pell | (1 + 1).AtLeastTwo | null | false |
PreTilt.valAux_one | Mathlib.RingTheory.Perfection | ∀ {K : Type u₁} [inst : Field K] {v : Valuation K NNReal} {O : Type u₂} [inst_1 : CommRing O] [inst_2 : Algebra O K],
v.Integers O → ∀ {p : ℕ} [inst_3 : Fact (Nat.Prime p)] [inst_4 : Fact ¬IsUnit ↑p], PreTilt.valAux K v O p 1 = 1 | null | true |
Fintype.decidableForallFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {p : α → Prop} [inst : Fintype α], (∀ a ∈ Finset.univ, p a) ↔ ∀ (a : α), p a | null | false |
Sublattice.isSublattice | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] (L : Sublattice α), IsSublattice ↑L | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.MBTC.0.Lean.Meta.Grind.Arith.Linear.isInterpreted | Lean.Meta.Tactic.Grind.Arith.Linear.MBTC | Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | true |
_private.Lean.PrettyPrinter.Parenthesizer.0.Lean.PrettyPrinter.categoryParenthesizerAttribute._regBuiltin.Lean.PrettyPrinter.categoryParenthesizerAttribute.docString_1 | Lean.PrettyPrinter.Parenthesizer | IO Unit | null | false |
SemigroupAction.mk | Mathlib.Algebra.Group.Action.Defs | {α : Type u_9} →
{β : Type u_10} →
[inst : Semigroup α] → [toSMul : SMul α β] → (∀ (x y : α) (b : β), (x * y) • b = x • y • b) → SemigroupAction α β | null | true |
_private.Mathlib.Analysis.Normed.Operator.NormedSpace.0.ContinuousLinearMap.opNNNorm_linearIsometryEquiv_comp._simp_1_1 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ... | null | false |
_private.Mathlib.Algebra.Homology.ShortComplex.Ab.0.CategoryTheory.ShortComplex.ShortExact.ab_finite_iff.match_1_1 | Mathlib.Algebra.Homology.ShortComplex.Ab | ∀ {S : CategoryTheory.ShortComplex Ab} (motive : Finite ↑S.X₁ ∧ Finite ↑S.X₃ → Prop) (x : Finite ↑S.X₁ ∧ Finite ↑S.X₃),
(∀ (left : Finite ↑S.X₁) (right : Finite ↑S.X₃), motive ⋯) → motive x | null | false |
_private.Lean.Meta.WHNF.0.Lean.Meta.smartUnfoldingReduce?.goMatch._sparseCasesOn_1 | Lean.Meta.WHNF | {motive : Lean.Meta.ReduceMatcherResult → Sort u} →
(t : Lean.Meta.ReduceMatcherResult) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.reduced val)) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.stuck val)) →
(Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.FieldTheory.LinearDisjoint.0.IntermediateField.LinearDisjoint.adjoin_rank_eq_rank_left_of_isAlgebraic.match_1_5 | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u_2} {E : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type u_3}
[inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E] (x : E),
let L' := (IsScalarTower.toAlgHom F L E).range;
∀ (motive : (∃ a, ∃ (b : a ∈ L'), (algebraMap (↥L') E) ... | null | false |
Std.DTreeMap.isEmpty_modify | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α} {f : β k → β k}, (t.modify k f).isEmpty = t.isEmpty | null | true |
Set.coe_singletonAddMonoidHom | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddZeroClass α], ⇑Set.singletonAddMonoidHom = singleton | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr.0.Std.Tactic.BVDecide.BVExpr.bitblast.go.match_17.eq_9 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | ∀ (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) (w n : ℕ) (lhs : Std.Tactic.BVDecide.BVExpr w)
(rhs : Std.Tactic.BVDecide.BVExpr n) (h_1 : (w a : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var a))
(h_2 : (w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val))
(h_3 :
(w : ℕ)... | null | true |
ContinuousLinearMap.toPseudoMetricSpace._proof_1 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜₂ : Type u_1} {F : Type u_2} [inst : SeminormedAddCommGroup F] [inst_1 : NontriviallyNormedField 𝕜₂]
[inst_2 : NormedSpace 𝕜₂ F], ContinuousConstSMul 𝕜₂ F | null | false |
Set.biUnion_singleton | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (a : α) (s : α → Set β), ⋃ x ∈ {a}, s x = s a | null | true |
ULiftable.refl | Mathlib.Control.ULiftable | (f : Type u₀ → Type u₁) → [inst : Functor f] → [LawfulFunctor f] → ULiftable f f | null | true |
CategoryTheory.IsRegularMono.fac_assoc | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y W : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.IsRegularMono f] (k : W ⟶ Y)
(h :
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.left f) =
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.right f))
{Z : C}... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.