name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.decidableForallFin._proof_1 | Init.Data.Nat.Lemmas | ∀ {n : ℕ} (P : Fin n → Prop), (∀ (k : ℕ) (h : k < n), P ⟨k, h⟩) ↔ ∀ (i : Fin n), P i | null | false |
Tactic.mkComp._sunfold | Mathlib.Tactic.HigherOrder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | null | false |
ContinuousMap.compactConvergenceUniformSpace | Mathlib.Topology.UniformSpace.CompactConvergence | {α : Type u₁} → {β : Type u₂} → [inst : TopologicalSpace α] → [inst_1 : UniformSpace β] → UniformSpace C(α, β) | Uniform space structure on `C(α, β)`.
The uniformity comes from `α →ᵤ[{K | IsCompact K}] β` (i.e., `UniformOnFun α β {K | IsCompact K}`)
which defines topology of uniform convergence on compact sets.
We use `ContinuousMap.tendsto_iff_forall_isCompact_tendstoUniformlyOn`
to show that the induced topology agrees with th... | true |
IsStarNormal.neg | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : StarAddMonoid R] {x : R} [IsStarNormal x], IsStarNormal (-x) | null | true |
GaussianInt.abs_natCast_norm | Mathlib.NumberTheory.Zsqrtd.GaussianInt | ∀ (x : GaussianInt), ↑(Zsqrtd.norm x).natAbs = Zsqrtd.norm x | null | true |
instAddGroupObjOppositeOpensCarrierOfPresheafSmoothSheaf._aux_8 | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_3} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_4} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_5} →
... | null | false |
StarAlgEquiv.trans_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} {C : Type u_5} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A]
[inst_3 : Mul B] [inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] [inst_8 : Add C]
[inst_9 : Mul C] [inst_10 : SMul R C] [inst_11 : Star C] (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (x... | null | true |
Std.DTreeMap.Internal.Impl.insertMin.match_3.congr_eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Sort u_3)
(t : Std.DTreeMap.Internal.Impl α β) (hr : t.Balanced)
(h_1 : (hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) → motive Std.DTreeMap.Internal.Impl.leaf hr)
(h_2 :
(sz : ℕ) →
(k' : α) →
(v' ... | null | true |
NNRat.instIsScalarTowerRight | Mathlib.Algebra.Ring.Action.Rat | ∀ {R : Type u_1} [inst : DivisionSemiring R], IsScalarTower ℚ≥0 R R | null | true |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.einfsep_insert._simp_1_1 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Set α} {d : ENNReal}, (d ≤ s.einfsep) = ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ edist x y | null | false |
NNRat.cast_div_of_ne_zero | Mathlib.Data.Rat.Cast.Defs | ∀ {α : Type u_3} [inst : DivisionSemiring α] {q r : ℚ≥0}, ↑q.den ≠ 0 → ↑r.num ≠ 0 → ↑(q / r) = ↑q / ↑r | null | true |
List.minOn_append._proof_1 | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {xs ys : List α}, xs ≠ [] → xs ++ ys ≠ [] | null | false |
norm_deriv_eq_norm_fderiv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, ‖deriv f x‖ = ‖fderiv 𝕜 f x‖ | null | true |
FreeGroup.Red.decidableRel._proof_3 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (x : α) (b : Bool) (tl : List (α × Bool)), FreeGroup.Red tl [(x, !b)] → FreeGroup.Red ((x, b) :: tl) [] | null | false |
Id.instLawfulMonadLiftTOfLawfulMonad | Init.Control.Lawful.MonadLift.Instances | ∀ {m : Type u → Type v} [inst : Monad m] [LawfulMonad m], LawfulMonadLiftT Id m | null | true |
DistribLattice.ctorIdx | Mathlib.Order.Lattice | {α : Type u_1} → DistribLattice α → ℕ | null | false |
RelIso.instGroup._proof_2 | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (n : ℕ) (x : r ≃r r), npowRecAuto (n + 1) x = npowRecAuto n x * x | null | false |
Std.Tactic.BVDecide.BVExpr.replicate.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w w' : ℕ} (n : ℕ) (expr : Std.Tactic.BVDecide.BVExpr w) (h : w' = w * n) (w_1 n_1 : ℕ)
(expr_1 : Std.Tactic.BVDecide.BVExpr w_1) (h_1 : w' = w_1 * n_1),
(Std.Tactic.BVDecide.BVExpr.replicate n expr h = Std.Tactic.BVDecide.BVExpr.replicate n_1 expr_1 h_1) =
(w = w_1 ∧ n = n_1 ∧ expr ≍ expr_1) | null | true |
RCLike.norm_coe_norm | Mathlib.Analysis.Normed.Module.RCLike.Basic | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] {z : E}, ‖↑‖z‖‖ = ‖z‖ | null | true |
Prod.map_iterate | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → α) (g : β → β) (n : ℕ), (Prod.map f g)^[n] = Prod.map f^[n] g^[n] | null | true |
_private.Init.Data.String.Lemmas.Intercalate.0.String.intercalate.go.eq_2 | Init.Data.String.Lemmas.Intercalate | ∀ (acc s : String), String.intercalate.go✝ acc s [] = acc | null | true |
WeierstrassCurve.Projective.addXYZ_Z | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P Q : Fin 3 → R), W'.addXYZ P Q 2 = W'.addZ P Q | null | true |
String.Legacy.Iterator.s | Init.Data.String.Iterator | String.Legacy.Iterator → String | The string being iterated over. | true |
PseudoMetric.coe_le_coe | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : Add R] [inst_2 : LE R] {d d' : PseudoMetric X R},
⇑d ≤ ⇑d' ↔ d ≤ d' | null | true |
AlgebraicGeometry.morphismRestrictStalkMap._proof_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) (x : ↥↑((TopologicalSpace.Opens.map f.base).obj U)),
Inseparable (↑((f ∣_ U) x)) (f ↑x) | null | false |
FreeAddGroup.Red.Step.sublist | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)}, FreeAddGroup.Red.Step L₁ L₂ → L₂.Sublist L₁ | null | true |
CategoryTheory.NatTrans.naturality | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (self : CategoryTheory.NatTrans F G) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (self.app Y) = CategoryTheory.CategoryStruct.comp (self.... | The naturality square for a given morphism. | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.modify._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {β : Type u_2} (m : Std.DHashMap α fun x => β) (a : α) (f : β → β),
(↑(Std.DHashMap.Internal.Raw₀.Const.modify ⟨m.inner, ⋯⟩ a f)).WF | null | false |
_private.Mathlib.Data.Finset.Union.0.Finset.bind_toFinset._simp_1_2 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a | null | false |
MvPowerSeries.eq_inv_iff_mul_eq_one | Mathlib.RingTheory.MvPowerSeries.Inverse | ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] {φ ψ : MvPowerSeries σ k},
MvPowerSeries.constantCoeff ψ ≠ 0 → (φ = ψ⁻¹ ↔ φ * ψ = 1) | null | true |
Set.singleton_inter_of_notMem | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, a ∉ s → {a} ∩ s = ∅ | **Alias** of the reverse direction of `Set.singleton_inter_eq_empty`. | true |
FreeSimplexQuiver.homRel.recOn | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {motive : ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ → (a a_1 : X ⟶ Y) → FreeSimplexQuiver.homRel a a_1 → Prop}
⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ {a a_1 : X ⟶ Y} (t : FreeSimplexQuiver.homRel a a_1),
(∀ {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.c... | null | false |
conditionallyCompleteLatticeOfsInf.eq_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (x : Type u_5) [x_1 : PartialOrder x] [x_2 : InfSet x] (x_3 : ∀ (a b : x), BddAbove {a, b})
(x_4 : ∀ (a b : x), BddBelow {a, b}) (isLUB_sSup : ∀ (s : Set x), BddBelow s → s.Nonempty → IsGLB s (sInf s)),
conditionallyCompleteLatticeOfsInf x x_3 x_4 isLUB_sSup =
{ toLattice := Lattice.ofIsLUBofIsGLB (fun a b =>... | null | true |
Lean.Parser.Term.optIdent.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
GrpCat.toAddGrp._proof_1 | Mathlib.Algebra.Category.Grp.EquivalenceGroupAddGroup | ∀ (X : GrpCat),
AddGrpCat.ofHom (MonoidHom.toAdditive (GrpCat.Hom.hom (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.CategoryStruct.id (AddGrpCat.of (Additive ↑X)) | null | false |
NumberField.mixedEmbedding.fundamentalCone.expMapBasis_nonneg | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.realSpace K)
(w : NumberField.InfinitePlace K), 0 ≤ ↑NumberField.mixedEmbedding.fundamentalCone.expMapBasis x w | null | true |
CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | (l : ℕ) →
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore (Fin (l + 1))
(fun r => ComplexShape.spectralSequenceFin l (r, 1 - r)) 2 | The data which allows to construct an `E₂`-cohomological spectral sequence
indexed by `ℤ × Fin l` from a spectral object indexed by `Fin (l + 1)`. | true |
WithBot.unbot_mono | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithBot α} (hx : x ≠ ⊥) (hy : y ≠ ⊥), x ≤ y → x.unbot hx ≤ y.unbot hy | **Alias** of the reverse direction of `WithBot.unbot_le_unbot_iff`. | true |
Algebra.traceMatrix._proof_1 | Mathlib.RingTheory.Trace.Basic | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A | null | false |
Real.strictAntiOn_rpow_Ioi_of_exponent_neg | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {r : ℝ}, r < 0 → StrictAntiOn (fun x => x ^ r) (Set.Ioi 0) | null | true |
antisymm_of | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} (r : α → α → Prop) [Std.Antisymm r] {a b : α}, r a b → r b a → a = b | A version of `antisymm` with `r` explicit.
This lemma matches the lemmas from lean core in `Init.Algebra.Classes`, but is missing there. | true |
Batteries.BinomialHeap.Imp.FindMin.recOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{motive : Batteries.BinomialHeap.Imp.FindMin α → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin α) →
((before : Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α) →
(val : α) →
(node : Batteries.BinomialHeap.Imp.HeapNode α) →
(next ... | null | false |
_private.Mathlib.Combinatorics.Enumerative.Partition.Glaisher.0.Nat.Partition.aux_mul_one_sub_X_pow._proof_1_2 | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : CommRing R] {m : ℕ},
0 < m → ∀ (i : ↑(Function.mulSupport fun i => 1 - (PowerSeries.X ^ (i + 1)) ^ m)), (↑i + 1) * m - 1 + 1 = (↑i + 1) * m | null | false |
isPurelyInseparable_iff | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u_1} {E : Type u_2} [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E],
IsPurelyInseparable F E ↔ ∀ (x : E), IsIntegral F x ∧ (IsSeparable F x → x ∈ (algebraMap F E).range) | null | true |
Pell.Solution₁.instCommGroup._proof_7 | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a : Pell.Solution₁ d), a * 1 = a | null | false |
Lean.Grind.CommRing.Poly.cancelVar | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | true |
CategoryTheory.Pseudofunctor.DescentData'.instCategory._proof_2 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryT... | null | false |
ContMDiffWithinAt.change_section_trivialization | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {M : Type u_5} {E : B → Type u_6}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_7} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_8} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSp... | null | true |
MvPolynomial.monomial_zero' | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], ⇑(MvPolynomial.monomial 0) = ⇑MvPolynomial.C | null | true |
CategoryTheory.Profunctor.op | Mathlib.CategoryTheory.Profunctor.Basic | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
CategoryTheory.Profunctor.{w, v₁, v₂, u₁, u₂} C D → CategoryTheory.Profunctor.{w, v₂, v₁, u₂, u₁} Dᵒᵖ Cᵒᵖ | The opposite of a profunctor. | true |
RatFunc.num_inv_dvd | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] {x : RatFunc K}, x ≠ 0 → x⁻¹.num ∣ x.denom | null | true |
WittVector.succNthValUnits.congr_simp | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (n : ℕ) (a a_1 : kˣ),
a = a_1 →
∀ (A A_1 : WittVector p k),
A = A_1 →
∀ (bs bs_1 : Fin (n + 1) → k),
bs = bs_1 → WittVector.succNthValUnits n a A bs = WittVector.succNthValUnits n a_1 A_1 bs_1 | null | true |
Cardinal.mk_finsupp_lift_of_infinite' | Mathlib.SetTheory.Cardinal.Finsupp | ∀ (α : Type u) (β : Type v) [Nonempty α] [inst : Zero β] [Infinite β],
Cardinal.mk (α →₀ β) = max (Cardinal.lift.{v, u} (Cardinal.mk α)) (Cardinal.lift.{u, v} (Cardinal.mk β)) | null | true |
Batteries.PairingHeap.headI | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → [Inhabited α] → Batteries.PairingHeap α le → α | `O(1)`. Returns the smallest element in the heap, or `default` if the heap is empty. | true |
Finset.measure_zero | Mathlib.MeasureTheory.Measure.Typeclasses.NoAtoms | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (s : Finset α) (μ : MeasureTheory.Measure α) [MeasureTheory.NoAtoms μ],
μ ↑s = 0 | null | true |
ContinuousMap.instStar | Mathlib.Topology.ContinuousMap.Star | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] → [inst_1 : TopologicalSpace β] → [inst_2 : Star β] → [ContinuousStar β] → Star C(α, β) | null | true |
Lean.Meta.RefinedDiscrTree.Key.bvar | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ℕ → ℕ → Lean.Meta.RefinedDiscrTree.Key | A bound variable, from a lambda or forall binder.
It stores the De Bruijn index and the arity. | true |
antitoneOn_of_le_sub_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Sub α] [inst_3 : One α]
[inst_4 : PredSubOrder α] [IsPredArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMin a → a ∈ s → a - 1 ∈ s → f a ≤ f (a - 1)) → AntitoneOn f s | null | true |
Lean.Grind.AC.diseq_simp_rhs_ac | Init.Grind.AC | ∀ {α : Sort u_1} (ctx : Lean.Grind.AC.Context α) {inst₁ : Std.Associative ctx.op} {inst₂ : Std.Commutative ctx.op}
(c lhs₁ rhs₁ lhs₂ rhs₂ rhs₂' : Lean.Grind.AC.Seq),
Lean.Grind.AC.simp_ac_cert c lhs₁ rhs₁ rhs₂ rhs₂' = true →
Lean.Grind.AC.Seq.denote ctx lhs₁ = Lean.Grind.AC.Seq.denote ctx rhs₁ →
Lean.Grin... | null | true |
Lean.isInstanceReducibleCore | Lean.ReducibilityAttrs | Lean.Environment → Lean.Name → Bool | null | true |
CommGroup.toDistribLattice._proof_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_1) [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
Lean.Elab.Term.ToDepElimPattern.State._sizeOf_inst | Lean.Elab.Match | SizeOf Lean.Elab.Term.ToDepElimPattern.State | null | false |
MulEquiv.withOneCongr._proof_2 | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] (e : α ≃* β) (x : WithOne α),
(WithOne.mapMulHom e.symm.toMulHom) ((WithOne.mapMulHom e.toMulHom) x) = x | null | false |
SimpleGraph.Hom.ofLE_apply | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {G₁ G₂ : SimpleGraph V} (h : G₁ ≤ G₂) (v : V), (SimpleGraph.Hom.ofLE h) v = v | null | true |
ONote.zero.elim | Mathlib.SetTheory.Ordinal.Notation | {motive : ONote → Sort u} → (t : ONote) → t.ctorIdx = 0 → motive ONote.zero → motive t | null | false |
Con.lift | Mathlib.GroupTheory.Congruence.Hom | {M : Type u_1} →
{P : Type u_3} →
[inst : MulOneClass M] → [inst_1 : MulOneClass P] → (c : Con M) → (f : M →* P) → c ≤ Con.ker f → c.Quotient →* P | The homomorphism on the quotient of a monoid by a congruence relation `c` induced by a
homomorphism constant on `c`'s equivalence classes. | true |
TopologicalSpace.Closeds.noncompactSpace_iff._simp_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], NoncompactSpace (TopologicalSpace.Closeds α) = NoncompactSpace α | null | false |
AdjoinRoot.instNumberFieldRat | Mathlib.NumberTheory.NumberField.Basic | ∀ {f : Polynomial ℚ} [hf : Fact (Irreducible f)], NumberField (AdjoinRoot f) | The quotient of `ℚ[X]` by the ideal generated by an irreducible polynomial of `ℚ[X]`
is a number field. | true |
Int.le_add_of_sub_left_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a - b ≤ c → a ≤ b + c | null | true |
Lean.ResolveName.resolveNamespaceUsingOpenDecls | Lean.ResolveName | Lean.Environment → Lean.Name → List Lean.OpenDecl → List Lean.Name | null | true |
HomotopicalAlgebra.PrepathObject.map_p₁ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (P : HomotopicalAlgebra.PrepathObject X) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] (F : CategoryTheory.Functor C D), (P.map F).p₁ = F.map P.p₁ | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft | ∀ {w : ℕ} (distance curr idx : ℕ), idx < curr → ¬idx < curr + 1 → False | null | false |
Int.mul_fmod_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod a = 0 | null | true |
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.map_eq_iff._simp_1_1 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type v} {β : ι → Type w} [inst : (i : ι) → AddCommMonoid (β i)] {x y : DirectSum ι β},
(x = y) = ∀ (i : ι), x i = y i | null | false |
Lean.Parser.OrElseOnAntiquotBehavior.rec | Lean.Parser.Basic | {motive : Lean.Parser.OrElseOnAntiquotBehavior → Sort u} →
motive Lean.Parser.OrElseOnAntiquotBehavior.acceptLhs →
motive Lean.Parser.OrElseOnAntiquotBehavior.takeLongest →
motive Lean.Parser.OrElseOnAntiquotBehavior.merge → (t : Lean.Parser.OrElseOnAntiquotBehavior) → motive t | null | false |
SkewMonoidAlgebra.algHom_ext | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : CommSemiring k] {A : Type u_3} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
⦃φ₁ φ₂ : SkewMonoidAlgebra k G →ₐ[k] A⦄,
(∀ (x : G), φ₁ (SkewMonoidAlgebra.single x 1) = φ₂ (SkewMonoidAlgebra.sin... | A `k`-algebra homomorphism from `SkewMonoidAlgebra k G` is uniquely defined by its
values on the functions `single a 1`. | true |
Mathlib.Meta.FunProp.LambdaTheoremArgs.ctorIdx | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremArgs → ℕ | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.alterₘ.match_1.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_3} {β : α → Type u_1} (a : α) (motive : Option (β a) → Sort u_2) (b : β a) (h_1 : Unit → motive none)
(h_2 : (b : β a) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Complex.cos_eq_cos_iff._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) | null | false |
Algebra.FormallyUnramified.localization_base | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u_1} {Rₘ : Type u_3} {Sₘ : Type u_4} [inst : CommRing R] [inst_1 : CommRing Rₘ] [inst_2 : CommRing Sₘ]
(M : Submonoid R) [inst_3 : Algebra R Sₘ] [inst_4 : Algebra R Rₘ] [inst_5 : Algebra Rₘ Sₘ] [IsScalarTower R Rₘ Sₘ]
[Algebra.FormallyUnramified R Sₘ], Algebra.FormallyUnramified Rₘ Sₘ | This actually does not need the localization instance, and is stated here again for
consistency. See `Algebra.FormallyUnramified.of_comp` instead.
The intended use is for copying proofs between `Formally{Unramified, Smooth, Etale}`
without the need to change anything (including removing redundant arguments). | true |
Std.HashMap.getKey!_eq_getKeyD_default | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {a : α}, m.getKey! a = m.getKeyD a default | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.specImpl | Batteries.Data.MLList.Basic | (m : Type u_1 → Type u_1) → MLList.Spec✝ m | null | true |
Lean.Omega.LinearCombo.sub | Init.Omega.LinearCombo | Lean.Omega.LinearCombo → Lean.Omega.LinearCombo → Lean.Omega.LinearCombo | Implementation of subtraction on `LinearCombo`. | true |
_private.Init.Data.List.Count.0.List.count_erase.match_1_1 | Init.Data.List.Count | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (c : α) (l : List α), motive (c :: l)) → motive x | null | false |
LieModule.toEnd_eq_iff | Mathlib.Algebra.Lie.OfAssociative | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [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]
[LieModule.IsFaithful R L M] {x y : L}, (LieModule.toEnd R L M) x = (LieModule.toEnd R L M) y ↔ x = y | null | true |
AddCommMonCat.FilteredColimits.M | Mathlib.Algebra.Category.MonCat.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.IsFiltered J] → CategoryTheory.Functor J AddCommMonCat → AddMonCat | The colimit of `F ⋙ forget₂ AddCommMonCat AddMonCat` in the category `AddMonCat`. In the
following, we will show that this has the structure of a _commutative_ additive monoid. | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_6 | Std.Time.Date.ValidDate | ∀ (idx : Std.Time.Month.Ordinal) (acc : ℤ),
12 ≤ ↑idx → ∀ (ordinal : Std.Time.Day.Ordinal.OfYear true), ↑ordinal ≤ 366 → 366 < ↑ordinal → False | null | false |
Vector.findFinIdx?_singleton._proof_1 | Init.Data.Vector.Find | ∀ {α : Type u_1} {a : α}, 0 < #[a].size | null | false |
_private.Mathlib.Data.Nat.Cast.NeZero.0.NeZero.one_le._proof_1_1 | Mathlib.Data.Nat.Cast.NeZero | ∀ {n : ℕ}, n ≠ 0 → 1 ≤ n | null | false |
CategoryTheory.Preadditive.toCommGrp_obj_grp | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C] (X : C),
((CategoryTheory.Preadditive.toCommGrp C).obj X).grp = CategoryTheory.Preadditive.instGrpObj X | null | true |
SSet.Subcomplex.PairingCore.index | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | {X : SSet} → {A : X.Subcomplex} → (self : A.PairingCore) → (s : self.ι) → Fin (self.dim s + 2) | the corresponding type (II) simplex is the `1`-codimensional
face given by this index | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_eq_default._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) | null | false |
Int.two_dvd_mul_add_one | Mathlib.Algebra.Ring.Int.Parity | ∀ (k : ℤ), 2 ∣ k * (k + 1) | null | true |
Plausible.Gen.oneOfWithDefault | Plausible.Gen | {α : Type} → Plausible.Gen α → List (Plausible.Gen α) → Plausible.Gen α | Picks one of the generators in `gs` at random, returning the `default` generator
if `gs` is empty.
(This is a more ergonomic version of Plausible's `Gen.oneOf` which doesn't
require the caller to supply a proof that the list index is in bounds.) | true |
CategoryTheory.FinCategory.objAsTypeToAsType | Mathlib.CategoryTheory.FinCategory.AsType | (α : Type u_1) →
[inst : Fintype α] →
[inst_1 : CategoryTheory.SmallCategory α] →
[inst_2 : CategoryTheory.FinCategory α] →
CategoryTheory.Functor (CategoryTheory.FinCategory.ObjAsType α) (CategoryTheory.FinCategory.AsType α) | The "identity" functor from `ObjAsType α` to `AsType α`. | true |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_4 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z) (T : CategoryTheory.Limits.FormalCoproduct C)
(s : { p // CategoryTheory.CategoryStruct.comp p.1 f = CategoryTheory.CategoryStruct.comp p.2 g }) (i : T.I),
Z.obj (f.f (↑⟨((↑s).1... | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.ExBase.toProd.match_1 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
(motive : Mathlib.Tactic.Ring.Common.Result bt q(Nat.rawCast 1) → Sort u_1) →
(x : Mathlib.Tactic.Ring.Common.Result bt q(Nat.rawCast 1)) →
((expr : Q(«$α»)) →
(one : bt e... | null | false |
LinearOrder.mkOfAddGroupCone.eq_1 | Mathlib.Algebra.Order.Group.Cone | ∀ {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] (C : S) [inst_2 : AddGroupConeClass S G]
[inst_3 : HasMemOrNegMem C] [inst_4 : DecidablePred fun x => x ∈ C],
LinearOrder.mkOfAddGroupCone C =
{ toPartialOrder := PartialOrder.mkOfAddGroupCone C, min := fun a b => if a ≤ b then a els... | null | true |
_private.Mathlib.Topology.EMetricSpace.Basic.0.EMetric.totallyBounded_iff'.match_1_1 | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {s : Set α} (ε : ENNReal)
(motive : (∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε) → Prop)
(x : ∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε),
(∀ (t : Set α) (left : t ⊆ s) (ft : t.Finite) (h : s ⊆ ⋃ y ∈ t, Metric.eball y ε), motive ⋯) → motive x | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.penultimate_mem_dropLast_support._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v},
[p.support.getLast ⋯].isEmpty = true → p.support.dropLast ≠ [] | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.