name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ConvexCone.Flat | Mathlib.Geometry.Convex.Cone.Basic | {R : Type u_2} →
{G : Type u_3} →
[inst : Semiring R] →
[inst_1 : PartialOrder R] → [inst_2 : AddCommGroup G] → [inst_3 : SMul R G] → ConvexCone R G → Prop | A convex cone is flat if it contains some nonzero vector `x` and its opposite `-x`. | true |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.vonStaudtIndicator | Mathlib.NumberTheory.Bernoulli | ℕ → ℕ → ℚ | null | true |
Stream'.Seq.ext_iff | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {s t : Stream'.Seq α}, s = t ↔ ∀ (n : ℕ), s.get? n = t.get? n | null | true |
BitVec.ssubOverflow | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → BitVec w → Bool | Checks whether the subtraction of `x` and `y` results in *signed* overflow, treating `x` and `y` as
2's complement signed bitvectors.
SMT-Lib name: `bvssubo`.
| true |
_private.Init.Data.List.Pairwise.0.List.pairwise_flatten._simp_1_6 | Init.Data.List.Pairwise | ∀ {α : Type u} {R : α → α → Prop} {a : α} {l : List α},
List.Pairwise R (a :: l) = ((∀ a' ∈ l, R a a') ∧ List.Pairwise R l) | null | false |
EisensteinSeries.summand_bound_of_mem_verticalStrip | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {z : UpperHalfPlane} {k : ℝ},
0 ≤ k →
∀ (x : Fin 2 → ℤ) {A B : ℝ} (hB : 0 < B),
z ∈ UpperHalfPlane.verticalStrip A B →
‖↑(x 0) * ↑z + ↑(x 1)‖ ^ (-k) ≤
EisensteinSeries.r { coe := { re := A, im := B }, coe_im_pos := hB } ^ (-k) * ‖x‖ ^ (-k) | null | true |
PontryaginDual.map_apply | Mathlib.Topology.Algebra.PontryaginDual | ∀ {A : Type u_1} {B : Type u_2} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] (f : A →ₜ* B) (x : PontryaginDual B) (y : A), ((PontryaginDual.map f) x) y = x (f y) | null | true |
SSet.Subcomplex.Pairing.RankFunction.filtration_monotone | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι),
Monotone f.filtration | null | true |
BoundedContinuousFunction.instNSMul.eq_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : AddMonoid R]
[inst_3 : BoundedAdd R] [inst_4 : ContinuousAdd R],
BoundedContinuousFunction.instNSMul =
{ smul := fun n f => { toFun := fun x => n • f x, continuous_toFun := ⋯, map_bounded' := ⋯ } } | null | true |
Int16.ofIntTruncate_int8ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int16.ofIntClamp x.toInt = x.toInt16 | null | true |
CategoryTheory.Limits.WidePullbackCone.reindex_pt | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_2} {X : C} {Y : ι → C} {f : (i : ι) → Y i ⟶ X}
(s : CategoryTheory.Limits.WidePullbackCone f) {ι' : Type u_3} (e : ι' ≃ ι), (s.reindex e).pt = s.pt | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (x : Lean.Grind.AC.Var) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (x_1 : Lean.Grind.AC.Var)
(c₁_1 : Lean.Meta.Grind.AC.EqCnstr),
(Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x c₁ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x_1 c₁_1) =
(x = x_1 ∧ c₁ = c₁_1) | null | true |
CategoryTheory.CoreHom._sizeOf_1 | Mathlib.CategoryTheory.Core | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{X Y : CategoryTheory.Core C} → [SizeOf C] → CategoryTheory.CoreHom X Y → ℕ | null | false |
UInt64.casesOn | Init.Prelude | {motive : UInt64 → Sort u} → (t : UInt64) → ((toBitVec : BitVec 64) → motive { toBitVec := toBitVec }) → motive t | null | false |
ModelWithCorners.toFun' | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] → {H : Type u_3} → [inst_3 : TopologicalSpace H] → ModelWithCorners 𝕜 E H → H → E | Coercion of a model with corners to a function. We don't use `e.toFun` because it is actually
`e.toPartialEquiv.toFun`, so `simp` will apply lemmas about `toPartialEquiv`. While we may want to
switch to this behavior later, doing it mid-port will break a lot of proofs. | true |
Inclusion.IntervalDyadicReal.binarySplit | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.BinarySplit | ℕ → Inclusion.Cover (Inclusion.Interval Dyadic) ℝ | Cover a dyadic interval by repeatedly bisecting it to depth `n`. | true |
isFixedPt_of_tendsto_iterate | Mathlib.Dynamics.FixedPoints.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] [T2Space α] {f : α → α} {x y : α},
Filter.Tendsto (fun n => f^[n] x) Filter.atTop (nhds y) → ContinuousAt f y → Function.IsFixedPt f y | If the iterates `f^[n] x` converge to `y` and `f` is continuous at `y`,
then `y` is a fixed point for `f`. | true |
MvPolynomial.eval₂Hom_X | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {S : Type v} [inst : CommRing S] {R : Type u} (c : ℤ →+* S) (f : MvPolynomial R ℤ →+* S) (x : MvPolynomial R ℤ),
MvPolynomial.eval₂ c (⇑f ∘ MvPolynomial.X) x = f x | A ring homomorphism `f : Z[X_1, X_2, ...] → R`
is determined by the evaluations `f(X_1)`, `f(X_2)`, ... | true |
ENNReal.log.eq_1 | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLog | ∀ (x : ENNReal), x.log = if x = 0 then ⊥ else if x = ⊤ then ⊤ else ↑(Real.log x.toReal) | null | true |
AddCommute.addSemiconjBy | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Add S] {a b : S}, AddCommute a b → AddSemiconjBy a b b | null | true |
Pi.inv_apply | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : (i : ι) → Inv (G i)] (f : (i : ι) → G i) (i : ι), f⁻¹ i = (f i)⁻¹ | null | true |
ZFSet.Definable.noConfusion | Mathlib.SetTheory.ZFC.Basic | {P : Sort u_1} →
{n : ℕ} →
{f : (Fin n → ZFSet.{u}) → ZFSet.{u}} →
{t : ZFSet.Definable n f} →
{n' : ℕ} →
{f' : (Fin n' → ZFSet.{u}) → ZFSet.{u}} →
{t' : ZFSet.Definable n' f'} → n = n' → f ≍ f' → t ≍ t' → ZFSet.Definable.noConfusionType P t t' | null | false |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.inj | Lean.Compiler.LCNF.JoinPoints | ∀ {candidates candidates_1 : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo},
{ candidates := candidates } = { candidates := candidates_1 } → candidates = candidates_1 | null | true |
BialgHom.noConfusionType | Mathlib.RingTheory.Bialgebra.Hom | Sort u →
{R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : Semiring B] →
[inst_4 : Algebra R B] →
[inst_5 : CoalgebraStruct R A] →
... | null | false |
Nat.toArray_roc_eq_nil_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...=n).toArray = #[] ↔ n ≤ m | null | true |
TopRep.d._proof_7 | Mathlib.RepresentationTheory.Homological.ContCohomology.Basic | ∀ {k : Type u_1} {G : Type u_3} [inst : Ring k] [inst_1 : Group G] [inst_2 : TopologicalSpace k]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (X : TopRep k G),
ContinuousConstSMul k ↑(X.resolutionX 0) | null | false |
Finset.le_piecewise_of_le_of_le | Mathlib.Data.Finset.Piecewise | ∀ {ι : Type u_1} (s : Finset ι) [inst : (j : ι) → Decidable (j ∈ s)] {π : ι → Type u_3} {f g h : (i : ι) → π i}
[inst_1 : (i : ι) → Preorder (π i)], h ≤ f → h ≤ g → h ≤ s.piecewise f g | null | true |
CategoryTheory.Limits.piConstAdj | Mathlib.CategoryTheory.Limits.Shapes.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasProducts C] →
(X : C) → (CategoryTheory.Limits.piConst.obj X).rightOp ⊣ CategoryTheory.yoneda.obj X | `n ↦ ∏ₙ X` is left adjoint to `Hom(-, X)`. | true |
List.gt_of_range'_eq_append_cons | Std.Do.Triple.SpecLemmas | ∀ {s n step : ℕ} {xs : List ℕ} {i : ℕ} {ys : List ℕ} {j : ℕ},
List.range' s n step = xs ++ i :: ys → 0 < step → j ∈ xs → j < i | null | true |
MonoidAlgebra.support_coeff_single_mul | Mathlib.Algebra.MonoidAlgebra.Support | ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Mul G] [inst_2 : IsLeftCancelMul G] (f : MonoidAlgebra k G)
(r : k),
(∀ (y : k), r * y = 0 ↔ y = 0) →
∀ (x : G), (MonoidAlgebra.single x r * f).coeff.support = Finset.map (mulLeftEmbedding x) f.coeff.support | null | true |
Mathlib.Tactic.Ring.Common.instInhabitedBtℕ | Mathlib.Tactic.Ring.Common | (e : Lean.Expr) → Inhabited (Mathlib.Tactic.Ring.Common.btℕ e) | null | true |
Path.Homotopy.pathCast | Mathlib.Topology.Homotopy.Path | {X : Type u} →
[inst : TopologicalSpace X] →
{x x' y y' : X} →
{p q : Path x y} → p.Homotopy q → (hx : x' = x) → (hy : y' = y) → (p.cast hx hy).Homotopy (q.cast hx hy) | If paths `p` and `q` are homotopic as paths `x ⟶ y`,
then they are homotopic as paths `x' ⟶ y'`, where `x' = x` and `y' = y`. | true |
SkewMonoidAlgebra.instRing._proof_7 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Ring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k]
(a : SkewMonoidAlgebra k G), 0 * a = 0 | null | false |
Lean.instBEqDataValue | Lean.Data.KVMap | BEq Lean.DataValue | null | true |
IsUltrametricDist.isUltrametricDist_iff_isNonarchimedean_nnnorm | Mathlib.Analysis.Normed.Group.Ultra | ∀ {R : Type u_3} [inst : SeminormedAddCommGroup R], IsUltrametricDist R ↔ IsNonarchimedean fun x => ↑‖x‖₊ | null | true |
IsCyclotomicExtension.autEquivPow._proof_4 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {n : ℕ} [inst : NeZero n] {K : Type u_1} [inst_1 : Field K] (L : Type u_2) [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] (x y : L ≃ₐ[K] L),
(↑(IsPrimitiveRoot.autToPow K ⋯)).toFun (x * y) =
(↑(IsPrimitiveRoot.autToPow K ⋯)).toFun x * (↑(IsPrimitive... | null | false |
GradedAlgHom.id._proof_1 | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ (R : Type u_2) {A : Type u_1} {ι : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(𝒜 : ι → Submodule R A) {i : ι} {x : A}, x ∈ 𝒜 i → ↑(GradedRingHom.id 𝒜) x ∈ 𝒜 i | null | false |
Finset.subtractionCommMonoid._proof_6 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : SubtractionCommMonoid α] (s : Finset α) (n : ℤ), ↑(n • s) = n • ↑s | null | false |
SSet.isColimitCokernelCoforkChainComplexDOneZero._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.HomologyZero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
(X : SSet) (R : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.sigmaConst.obj R).map (CategoryTheory.SimplicialObject.δ X 1))
((CategoryTheory.Limits.sigmaConst.obj R).map (Typ... | null | false |
GrpMax | Mathlib.Algebra.Category.Grp.Basic | Type ((max u1 u2) + 1) | An alias for `GrpCat.{max u v}`, to deal around unification issues. | true |
GrpCat.forget_createsLimit.eq_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J GrpCat),
GrpCat.forget_createsLimit F =
CategoryTheory.createsLimitOfNatIso
(CategoryTheory.Iso.refl ((CategoryTheory.forget₂ GrpCat MonCat).comp (CategoryTheory.forget MonCat))) | null | true |
Ideal.powQuotSuccInclusion_injective | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R) (P : Ideal S)
(i : ℕ), Function.Injective ⇑(p.powQuotSuccInclusion P i) | null | true |
Lean.Elab.WF.EqnInfo._sizeOf_inst | Lean.Elab.PreDefinition.WF.Eqns | SizeOf Lean.Elab.WF.EqnInfo | null | false |
Topology.IsScott.scottContinuousOn_iff_continuous | Mathlib.Topology.Order.ScottTopology | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Preorder β]
[inst_3 : TopologicalSpace β] [Topology.IsScott β Set.univ] {f : α → β} {D : Set (Set α)} [Topology.IsScott α D],
(∀ (a b : α), a ≤ b → {a, b} ∈ D) → (ScottContinuousOn D f ↔ Continuous f) | null | true |
Algebra.QuasiFinite.recOn | Mathlib.RingTheory.QuasiFinite.Basic | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{motive : Algebra.QuasiFinite R S → Sort u} →
(t : Algebra.QuasiFinite R S) →
((finite_fiber : ∀ (P : Ideal R) [inst_3 : P.IsPrime], Module.Finite P.ResidueFie... | null | false |
Class.instCompleteLattice._aux_12 | Mathlib.SetTheory.ZFC.Class | Class.{u_1} → Class.{u_1} → Class.{u_1} | null | false |
lift_trdeg_le_of_surjective | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {R : Type u_2} {A : Type v} {A' : Type v'} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing A']
[inst_3 : Algebra R A] [inst_4 : Algebra R A'] (f : A →ₐ[R] A'),
Function.Surjective ⇑f → Cardinal.lift.{v, v'} (Algebra.trdeg R A') ≤ Cardinal.lift.{v', v} (Algebra.trdeg R A) | null | true |
Std.ExtDHashMap.getKey_diff | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {h_mem : k ∈ m₁ \ m₂}, (m₁ \ m₂).getKey k h_mem = m₁.getKey k ⋯ | null | true |
Set.image_single_uIcc_left | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Lattice (α i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → Zero (α i)] (i : ι) (a : α i), Pi.single i '' Set.uIcc a 0 = Set.uIcc (Pi.single i a) 0 | null | true |
Std.DTreeMap.Internal.Impl.getD_insertMany_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq)
{v : β k} {fallback : β k'},
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
... | null | true |
Lean.Lsp.CompletionItemTag._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CompletionItemTag | null | false |
ite_neg | Mathlib.Algebra.Notation.Lemmas | ∀ {α : Type u_1} [inst : Zero α] {p : Prop} [inst_1 : Decidable p] {a b : α} [inst_2 : LT α],
a < 0 → b < 0 → (if p then a else b) < 0 | null | true |
CategoryTheory.SimplicialThickening.functorMap._proof_6 | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J K : Type u_1} [inst : LinearOrder J] [inst_1 : LinearOrder K] (f : J →o K)
(i j : CategoryTheory.SimplicialThickening J) (I : i ⟶ j), f j.as ∈ ⇑f '' I.I | null | false |
CategoryTheory.injectiveResolutions._proof_3 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | IsRightCancelAdd ℕ | null | false |
Subfield.inf_relfinrank_left | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B : Subfield E), (A ⊓ B).relfinrank A = B.relfinrank A | null | true |
CategoryTheory.Bicategory.InducedBicategory.Hom₂._sizeOf_1 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
{inst : CategoryTheory.Bicategory C} →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} → [SizeOf B] → [SizeOf C] → CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → ℕ | null | false |
SSet.anodyneExtensions.whiskerLeft | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PushoutProduct | ∀ {X Y : SSet} {f : X ⟶ Y},
SSet.anodyneExtensions f →
∀ (Z : SSet), SSet.anodyneExtensions (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f) | null | true |
Submodule.starProjection_apply | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(U : Submodule 𝕜 E) [inst_3 : U.HasOrthogonalProjection] (v : E), U.starProjection v = ↑(U.orthogonalProjectionOnto v) | null | true |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.mk | Mathlib.AlgebraicTopology.ExtraDegeneracy | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject.Augmented C} →
(s' : X.right ⟶ X.left.obj (Opposite.op { len := 0 })) →
(s : (n : ℕ) → X.left.obj (Opposite.op { len := n }) ⟶ X.left.obj (Opposite.op { len := n + 1 })) →
autoParam
... | null | true |
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor_map | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{X Y : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y),
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor.map f =
CategoryTheory.ComposableArrows.homMk₅ f.f₀.τ₁ f.f₀.τ₂ f.f₀.τ₃ f.f₃.τ₁ f.f₃.τ₂ f... | null | true |
ProofWidgets.instToJsonRpcEncodablePacket._@.ProofWidgets.Presentation.Expr.1937505173._hygCtx._hyg.29 | ProofWidgets.Presentation.Expr | Lean.ToJson ProofWidgets.RpcEncodablePacket✝ | null | false |
CategoryTheory.Functor.const.opObjUnop._proof_1 | Mathlib.CategoryTheory.Functor.Const | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] (X : Cᵒᵖ) ⦃X_1 Y : Jᵒᵖ⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.unop X)).map f)
(CategoryTheory.CategoryStruct.id (((Catego... | null | false |
TopologicalSpace.OpenNhdsOf.comap | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(f : C(α, β)) → (x : α) → LatticeHom (TopologicalSpace.OpenNhdsOf (f x)) (TopologicalSpace.OpenNhdsOf x) | Preimage of an open neighborhood of `f x` under a continuous map `f` as a `LatticeHom`. | true |
Subarray.mkSlice_roc_eq_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
Std.Roc.Sliceable.mkSlice xs (lo<...=hi) = Std.Roo.Sliceable.mkSlice xs (lo<...hi + 1) | null | true |
Ideal.isMaximal_of_isIntegral_of_isMaximal_comap | Mathlib.RingTheory.Ideal.GoingUp | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] (f : R →+* S),
f.IsIntegral → ∀ (I : Ideal S) [I.IsPrime], (Ideal.comap f I).IsMaximal → I.IsMaximal | null | true |
uniformity_hasBasis_open | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α], (uniformity α).HasBasis (fun V => V ∈ uniformity α ∧ IsOpen V) id | Open elements of `𝓤 α` form a basis of `𝓤 α`. | true |
IntermediateField.extendRight.instSMulSubtypeMem | Mathlib.FieldTheory.IntermediateField.ExtendRight | {K : Type u_1} →
{L : Type u_2} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
(F : IntermediateField K L) →
(M : Type u_3) →
[inst_3 : Field M] →
[inst_4 : Algebra K M] →
[inst_5 : Algebra L M] →
... | null | true |
TotallyBounded.exists_prodMk_finset_mem_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] {s : Set α},
TotallyBounded s → ∀ {U : SetRel α α}, U ∈ uniformity α → ∃ t, (↑t, s) ∈ hausdorffEntourage U | null | true |
Lean.Lsp.instFromJsonRenameOptions.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.RenameOptions | null | true |
Lean.Meta.SimpTheorems.isDeclToUnfold | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Meta.SimpTheorems → Lean.Name → Bool | Return `true` if `declName` is tagged to be unfolded using `unfoldDefinition?` (i.e., without using equational theorems). | true |
Unitization.ind | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_5} {A : Type u_6} [inst : AddZeroClass R] [inst_1 : AddZeroClass A] {P : Unitization R A → Prop},
(∀ (r : R) (a : A), P (Unitization.inl r + ↑a)) → ∀ (x : Unitization R A), P x | To show a property hold on all `Unitization R A` it suffices to show it holds
on terms of the form `inl r + a`.
This can be used as `induction x`. | true |
Representation.tprod._proof_1 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_3} {G : Type u_4} {V : Type u_1} {W : Type u_2} [inst : CommSemiring k] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : Module k V] [inst_4 : AddCommMonoid W] [inst_5 : Module k W]
(ρV : Representation k G V) (ρW : Representation k G W), TensorProduct.map (ρV 1) (ρW 1) = 1 | null | false |
Ordinal.omega_natCast_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {o : Ordinal.{u}} {n : ℕ}, (Ordinal.omega ↑n ≤ Ordinal.lift.{v, u} o) = (Ordinal.omega ↑n ≤ o) | null | false |
_private.Batteries.Data.Vector.Basic.0.Vector.scanlMFast.loop._proof_3 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (i n_usize : USize), n_usize.toNat = n → i.toNat < n → (i + 1).toNat = i.toNat + 1 → (i + 1).toNat ≤ n | null | false |
Complex.polarCoord_symm_apply | Mathlib.Analysis.SpecialFunctions.PolarCoord | ∀ (p : ℝ × ℝ), ↑Complex.polarCoord.symm p = ↑p.1 * (↑(Real.cos p.2) + ↑(Real.sin p.2) * Complex.I) | null | true |
Multiset.sum_map_sum_map | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {ι : Type u_2} {κ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] (m : Multiset ι) (n : Multiset κ)
{f : ι → κ → M},
(Multiset.map (fun a => (Multiset.map (fun b => f a b) n).sum) m).sum =
(Multiset.map (fun b => (Multiset.map (fun a => f a b) m).sum) n).sum | null | true |
String.any_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (p : Char → Bool), String.Legacy.any s p = true ↔ ∃ c ∈ s.toList, p c = true | null | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.DirectoryDependency.458526677._hygCtx._hyg.4 | Mathlib.Tactic.Linter.DirectoryDependency | IO (Lean.Option Bool) | null | false |
Std.Do.SPred.or_intro_r' | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, (P ⊢ₛ R) → P ⊢ₛ Q ∨ R | null | true |
Subbimodule.toSubmodule' | Mathlib.Algebra.Module.Bimodule | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{M : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : Semiring A] →
[inst_4 : Semiring B] →
[inst_5 : Module A M] →
... | Forgetting the `A` action, a `Submodule` over `A ⊗[R] B` is just a `Submodule` over `B`. | true |
CategoryTheory.Limits.pointwiseProductCompEvaluation._proof_2 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_7, u_6} D] {α : Type u_3} {I : α → Type u_5}
[inst_2 : (i : α) → CategoryTheory.Category.{u_4, u_5} (I i)]
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete α) C]
(F : (i : ... | null | false |
Lean.Grind.LinarithConfig.instances._inherited_default | Init.Grind.Config | ℕ | null | false |
UInt8.ofFin_and | Init.Data.UInt.Bitwise | ∀ (a b : Fin UInt8.size), UInt8.ofFin (a &&& b) = UInt8.ofFin a &&& UInt8.ofFin b | null | true |
ZLattice.covolume.tendsto_card_le_div | Mathlib.Algebra.Module.ZLattice.Covolume | ∀ {ι : Type u_1} [inst : Fintype ι] (L : Submodule ℤ (ι → ℝ)) [inst_1 : DiscreteTopology ↥L] [IsZLattice ℝ L]
{X : Set (ι → ℝ)},
(∀ ⦃x : ι → ℝ⦄ ⦃r : ℝ⦄, x ∈ X → 0 < r → r • x ∈ X) →
∀ {F : (ι → ℝ) → ℝ},
(∀ (x : ι → ℝ) ⦃r : ℝ⦄, 0 ≤ r → F (r • x) = r ^ Fintype.card ι * F x) →
Bornology.IsBounded {x ... | null | true |
Std.TreeMap.Raw.getEntryLT! | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Inhabited (α × β)] → Std.TreeMap.Raw α β cmp → α → α × β | Tries to retrieve the key-value pair with the largest key that is less than the given key,
panicking if no such pair exists.
| true |
Complementeds.instMax._proof_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : BoundedOrder α] (a b : Complementeds α), IsComplemented (↑a ⊔ ↑b) | null | false |
NonUnitalNormedRing.rec | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
{motive : NonUnitalNormedRing α → Sort u} →
([toNorm : Norm α] →
[toNonUnitalRing : NonUnitalRing α] →
[toMetricSpace : MetricSpace α] →
(dist_eq : ∀ (x y : α), dist x y = ‖-x + y‖) →
(norm_mul_le : ∀ (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖) →
mo... | null | false |
Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₂ | Aesop.Util.EqualUpToIds | Lean.Expr → Lean.Expr → Aesop.EqualUpToIds.ExprsEqualUpToIdsM Bool | null | true |
Rep.Tor._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G],
CategoryTheory.HasProjectiveResolutions (Rep.{u_1, u_1, u_1} k G) | null | false |
_private.Lean.Meta.FunInfo.0.Lean.Meta.collectDeps.visit._f | Lean.Meta.FunInfo | Array Lean.Expr → (e : Lean.Expr) → Lean.Expr.below (motive := fun e => Array ℕ → Array ℕ) e → Array ℕ → Array ℕ | null | false |
CoxeterSystem.getElem_alternatingWord._proof_1 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (p k : ℕ), k < p → k < (CoxeterSystem.alternatingWord i j p).length | null | false |
IsJordan.casesOn | Mathlib.Algebra.Jordan.Basic | {A : Type u_1} →
[inst : Mul A] →
{motive : IsJordan A → Sort u} →
(t : IsJordan A) →
((lmul_comm_rmul : ∀ (a b : A), a * b * a = a * (b * a)) →
(lmul_lmul_comm_lmul : ∀ (a b : A), a * a * (a * b) = a * (a * a * b)) →
(lmul_lmul_comm_rmul : ∀ (a b : A), a * a * (b * a) = a ... | null | false |
Profinite.NobelingProof.iso_map._proof_3 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} (C : Set (I → Bool)) (J : I → Prop) [inst : (i : I) → Decidable (J i)],
Continuous fun x => ⟨fun i => ↑x ↑i, ⋯⟩ | null | false |
MaximalSpectrum.mk.injEq | Mathlib.RingTheory.Spectrum.Maximal.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (asIdeal : Ideal R) (isMaximal : asIdeal.IsMaximal) (asIdeal_1 : Ideal R)
(isMaximal_1 : asIdeal_1.IsMaximal),
({ asIdeal := asIdeal, isMaximal := isMaximal } = { asIdeal := asIdeal_1, isMaximal := isMaximal_1 }) =
(asIdeal = asIdeal_1) | null | true |
UpperHalfPlane.hasDerivAt_denom_zpow | Mathlib.Analysis.Complex.UpperHalfPlane.Manifold | ∀ (g : GL (Fin 2) ℝ) (k : ℤ) (τ : UpperHalfPlane),
HasDerivAt (fun z => UpperHalfPlane.denom g z ^ k) (↑k * ↑(↑g 1 0) * UpperHalfPlane.denom g ↑τ ^ (k - 1)) ↑τ | Derivative of `z ↦ (denom g z) ^ k`: $\frac{d}{dz}[(cz+d)^k] = k \cdot c \cdot (cz+d)^{k-1}$. | true |
AffineIsometryEquiv.coe_one | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_7} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P], ⇑1 = id | null | true |
CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryCoproduct X Y],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr 0 0)
(Cat... | null | true |
ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice | Mathlib.Order.ConditionallyCompleteLattice.Defs | {α : Type u_2} → [self : ConditionallyCompleteLinearOrder α] → ConditionallyCompleteLattice α | null | true |
CategoryTheory.Functor.Fiber.homMk._proof_2 | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u_1} {𝒳 : Type u_4} [inst : CategoryTheory.Category.{u_3, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_4} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) (S : 𝒮) {a b : 𝒳} (φ : a ⟶ b)
[p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ], p.obj b = S | null | false |
Int.dvd_ediv_iff_mul_dvd._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, c ∣ b → (a ∣ b / c) = (c * a ∣ b) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.