name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
isUnit_star._simp_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] {a : R}, IsUnit (star a) = IsUnit a | null | false |
Finset.map_toDual_max | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α),
WithBot.map (⇑OrderDual.toDual) s.max = (Finset.image (⇑OrderDual.toDual) s).min | null | true |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.iSupIndep_iff_supIndep.match_1_10 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] (s : Finset α) (a : α) (motive : ¬a = ⊥ ∧ a ∈ s → Prop)
(x : ¬a = ⊥ ∧ a ∈ s), (∀ (ha : ¬a = ⊥) (has : a ∈ s), motive ⋯) → motive x | null | false |
Mathlib.Tactic.AtomM.addAtom | Mathlib.Util.AtomM | Lean.Expr → Mathlib.Tactic.AtomM (ℕ × Lean.Expr) | If an atomic expression has already been encountered, get the index and the stored form of the
atom (which will be defeq at the specified transparency, but not necessarily syntactically equal).
If the atomic expression has *not* already been encountered, store it in the list of atoms, and
return the new index (and the ... | true |
Hyperreal.inv_epsilon | Mathlib.Analysis.Real.Hyperreal | Hyperreal.epsilon⁻¹ = Hyperreal.omega | null | true |
instCompleteAtomicBooleanAlgebraLanguage._aux_14 | Mathlib.Computability.Language | (α : Type u_1) → Language α → Language α → Language α | null | false |
CategoryTheory.PreZeroHypercover.pullback₂_I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f : S ⟶ T) (E : CategoryTheory.PreZeroHypercover T)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f],
(CategoryTheory.PreZeroHypercover.pullback₂ f E).I₀ = E.I₀ | null | true |
Matrix.uniformContinuous | Mathlib.Topology.UniformSpace.Matrix | ∀ (m : Type u_1) (n : Type u_2) (𝕜 : Type u_3) [inst : UniformSpace 𝕜] {β : Type u_4} [inst_1 : UniformSpace β]
{f : β → Matrix m n 𝕜}, UniformContinuous f ↔ ∀ (i : m) (j : n), UniformContinuous fun x => f x i j | null | true |
Vector.scanl | Batteries.Data.Vector.Basic | {β : Type u_1} → {α : Type u_2} → {n : ℕ} → (β → α → β) → β → Vector α n → Vector β (n + 1) | Fold a function `f` over the list from the left, returning the vector of partial results.
| true |
Hindman.FP_partition_regular | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] (a : Stream' M) (s : Set (Set M)),
s.Finite → Hindman.FP a ⊆ ⋃₀ s → ∃ c ∈ s, ∃ b, Hindman.FP b ⊆ c | The strong form of **Hindman's theorem**: in any finite cover of an FP-set, one the parts
contains an FP-set. | true |
List.zipWithLeft'._f | Batteries.Data.List.Basic | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
(α → Option β → γ) →
(x : List α) → List.below (motive := fun x => List β → List γ × List β) x → List β → List γ × List β | null | false |
_private.Mathlib.Algebra.NeZero.0.not_neZero._simp_1_1 | Mathlib.Algebra.NeZero | ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n = (n ≠ 0) | null | false |
CategoryTheory.Limits.ReflectsColimitsOfSize.reflectsColimitsOfShape._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Basic | Lean.Syntax | null | false |
List.sum_flatten | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Add α] [inst_1 : Zero α] [Std.LawfulIdentity (fun x1 x2 => x1 + x2) 0]
[Std.Associative fun x1 x2 => x1 + x2] {l : List (List α)}, l.flatten.sum = (List.map List.sum l).sum | null | true |
ProbabilityTheory.IsMeasurableRatCDF.le_one | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ},
ProbabilityTheory.IsMeasurableRatCDF f → ∀ (a : α) (q : ℚ), f a q ≤ 1 | null | true |
mod_natCard_zsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : AddGroup G] (a : G) (n : ℤ), (n % ↑(Nat.card G)) • a = n • a | null | true |
TopologicalSpace.Clopens.ctorIdx | Mathlib.Topology.Sets.Closeds | {α : Type u_4} → {inst : TopologicalSpace α} → TopologicalSpace.Clopens α → ℕ | null | false |
Fin.addCases._proof_2 | Init.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m + n)) (hi : ¬↑i < m), Fin.natAdd m (Fin.subNat m (Fin.cast ⋯ i) ⋯) = i | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey?_erase_le_maxKey?._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 |
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.ppEqcs?._sparseCasesOn_1 | Lean.Elab.Tactic.Grind.ShowState | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.List.Chain.0.List.exists_isChain_ne_nil_of_relationReflTransGen._proof_1_2 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} (l : List α), ¬a :: l = [] | null | false |
MonoidHom.submonoidMap_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {f : M →* N},
Function.Injective ⇑f → ∀ (M' : Submonoid M), Function.Injective ⇑(f.submonoidMap M') | null | true |
Matrix.decidableEq | Mathlib.Data.Matrix.Basic | {m : Type u_2} →
{n : Type u_3} → {α : Type u_11} → [DecidableEq α] → [Fintype m] → [Fintype n] → DecidableEq (Matrix m n α) | null | true |
_private.Mathlib.RingTheory.WittVector.Frobenius.0.WittVector.frobenius._simp_2 | Mathlib.RingTheory.WittVector.Frobenius | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.simp | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ℤ →
Lean.Meta.Grind.Arith.CommRing.EqCnstr →
ℤ → Lean.Grind.CommRing.Mon → Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.EqCnstrProof | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mapIdIso._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.StrictlyUnitaryLaxFunctor B C) (x : B),
CategoryTheory.CategoryStruct.comp (F.mapId x) (CategoryTheory.eqToHom ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id (... | null | false |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages.0.CategoryTheory.Abelian.PreservesCoimage.hom_coimageImageComparison._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) | null | false |
_private.Mathlib.RingTheory.Polynomial.ScaleRoots.0.Polynomial.scaleRoots_dvd_iff._simp_1_1 | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p : Polynomial R) (r s : R),
(p.scaleRoots r).scaleRoots s = p.scaleRoots (r * s) | null | false |
AddAction.period_pos_of_addOrderOf_pos | Mathlib.GroupTheory.GroupAction.Period | ∀ {α : Type v} {M : Type u} [inst : AddMonoid M] [inst_1 : AddAction M α] {m : M},
0 < addOrderOf m → ∀ (a : α), 0 < AddAction.period m a | null | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Mathlib.Meta.Positivity.evalDist._proof_2 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ (α : Q(Type)) (_pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$_pα» =Q Real.partialOrder)),
«$_pα» =Q Real.partialOrder | null | false |
ProofWidgets.instFromJsonRpcEncodablePacket._@.ProofWidgets.Component.HtmlDisplay.3039065598._hygCtx._hyg.10 | ProofWidgets.Component.HtmlDisplay | Lean.FromJson ProofWidgets.RpcEncodablePacket✝ | null | false |
_private.Mathlib.Topology.Algebra.IsUniformGroup.Defs.0.UniformContinuous.pow_const.match_1_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Std.Time.PlainDate.instToString | Std.Time.Format | ToString Std.Time.PlainDate | null | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.atomise_empty._simp_1_4 | Mathlib.Order.Partition.Finpartition | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
Int.toArray_roc_eq_push | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m < n → (m<...=n).toArray = (m<...=n - 1).toArray.push n | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0.WeierstrassCurve.Projective.Point.toAffine_some._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} (a b c : R), ![a, b, c] 2 = c | null | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.DerivedLitsInvariant._proof_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n),
f.assignments.size = n →
∀ (assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment),
assignments.size = n →
∀ (derivedLits : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (i : Fin n),
↑i < n → ... | null | false |
Monoid.CoprodI.NeWord.toList.induct_unfolding | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)]
(motive : {i j : ι} → Monoid.CoprodI.NeWord M i j → List ((i : ι) × M i) → Prop),
(∀ (i : ι) (x : M i) (a : x ≠ 1), motive (Monoid.CoprodI.NeWord.singleton x a) [⟨i, x⟩]) →
(∀ (x x_1 j k : ι) (w₁ : Monoid.CoprodI.NeWord M x j) (_hne : j ≠ k) (w... | null | true |
Bornology.ext_iff' | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {t t' : Bornology α}, t = t' ↔ ∀ (s : Set α), s ∈ Bornology.cobounded α ↔ s ∈ Bornology.cobounded α | null | true |
_private.Lean.Compiler.ExternAttr.0.Lean.parseOptNum._unary | Lean.Compiler.ExternAttr | (pattern : String.Slice) → (_ : pattern.Pos) ×' ℕ → pattern.Pos × ℕ | null | false |
CategoryTheory.Limits.isEqualizerCompMono._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : X ⟶ Y}
{c : CategoryTheory.Limits.Fork f g} {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.CategoryStruct.comp f h) =
CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.CategoryStruct.comp g h) | null | false |
Nat.count_true | Mathlib.Data.Nat.Count | ∀ (n : ℕ), Nat.count (fun x => True) n = n | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.ReplicateTarget.mk.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {combined : ℕ} [inst_2 : SizeOf α]
{w : ℕ} (n : ℕ) (inner : aig.RefVec w) (h : combined = w * n),
sizeOf { w := w, n := n, inner := inner, h := h } = 1 + sizeOf w + sizeOf n + sizeOf inner + sizeOf h | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget.mk.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {w : ℕ} [inst_2 : SizeOf α] {len : ℕ}
(x : aig.RefVec (len * w)) (h : 0 < len), sizeOf { len := len, x := x, h := h } = 1 + sizeOf len + sizeOf x + sizeOf h | null | true |
MeasureTheory.Measure.instAdd._proof_2 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α} (μ₁ μ₂ : MeasureTheory.Measure α),
(μ₁.toOuterMeasure + μ₂.toOuterMeasure).trim ≤ μ₁.toOuterMeasure + μ₂.toOuterMeasure | null | false |
Filter.map₂ | Mathlib.Order.Filter.NAry | {α : Type u_1} → {β : Type u_3} → {γ : Type u_5} → (α → β → γ) → Filter α → Filter β → Filter γ | The image of a binary function `m : α → β → γ` as a function `Filter α → Filter β → Filter γ`.
Mathematically this should be thought of as the image of the corresponding function `α × β → γ`. | true |
Lean.Parser.Command.openRenaming | Lean.Parser.Command | Lean.Parser.Parser | null | true |
Order.IsPredLimit.isMin | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : PredOrder α], Order.IsPredLimit (Order.pred a) → IsMin a | null | true |
Real.norm_two | Mathlib.Analysis.Normed.Group.Real | ‖2‖ = 2 | null | true |
instCommRingPointedContMDiffMap._aux_4 | Mathlib.Geometry.Manifold.DerivationBundle | (𝕜 : 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] →
(I : ModelWithCorners 𝕜 E H) →
(M : Type u_4) →
... | null | false |
CategoryTheory.PreZeroHypercover.empty | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (S : C) → CategoryTheory.PreZeroHypercover S | The empty pre-`0`-hypercover. | true |
Std.Time.instHSubOffsetOffset_21 | Std.Time.Date.Basic | HSub Std.Time.Minute.Offset Std.Time.Hour.Offset Std.Time.Minute.Offset | null | true |
MeasureTheory.L2.innerProductSpace._private_1 | Mathlib.MeasureTheory.Function.L2Space | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] (f : ↥(MeasureTheory.Lp E 2 μ)),
‖f‖ ^ 2 = RCLike.re (inner 𝕜 f f) | null | false |
Std.HashSet.get!_diff_of_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, k ∈ m₂ → (m₁ \ m₂).get! k = default | null | true |
Array.mergeSort_perm | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {xs : Array α} {le : α → α → Bool}, (xs.mergeSort le).Perm xs | null | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_insert._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∉ s → (insert a s).erase a = s | null | false |
WeierstrassCurve.Jacobian.negY_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R}, P 2 = 0 → W'.negY P = -P 1 | null | true |
Turing.TM1to1.write._f | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
(x : List Bool) →
List.below (motive := fun x =>
Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ → Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ) x →
Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ → Turing.TM1.Stmt Bool (Tur... | null | false |
_private.Mathlib.Dynamics.Ergodic.Action.Regular.0.instErgodicSMulOfIsMulLeftInvariant._simp_1 | Mathlib.Dynamics.Ergodic.Action.Regular | ∀ {α : Type u_1} {l : Filter α} {s : Set α},
Filter.EventuallyConst s l = ((∀ᶠ (x : α) in l, x ∈ s) ∨ ∀ᶠ (x : α) in l, x ∉ s) | null | false |
CategoryTheory.ShortComplex.mapHomologyIso | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(S : CategoryTheory.ShortComplex C) →
... | When a functor `F` preserves the left homology of a short complex `S`, this is the
canonical isomorphism `(S.map F).homology ≅ F.obj S.homology`. | true |
instFieldCyclotomicField._proof_41 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_1) [inst : Field K],
autoParam
(∀ (n_1 : ℕ) (a : CyclotomicField n K),
instFieldCyclotomicField._aux_37 n K (Int.negSucc n_1) a = -instFieldCyclotomicField._aux_37 n K (↑n_1.succ) a)
SubNegMonoid.zsmul_neg'._autoParam | null | false |
differentiable_finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i : Fin n) → F... | null | true |
Lex.instLeftCancelSemigroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [LeftCancelSemigroup α] → LeftCancelSemigroup (Lex α) | null | true |
CategoryTheory.MonoidalCategory.pentagon_hom_inv_inv_inv_hom | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y Z : C},
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator W X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)).hom
(CategoryTheory.CategoryStruct.comp
... | null | true |
Lean.JsonRpc.instBEqErrorCode.beq | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode → Lean.JsonRpc.ErrorCode → Bool | null | true |
RBTree.RBNode.isOrdered._f | BatteriesRecycling.RBTree.Basic | {α : Type u_1} →
(α → α → Ordering) →
(t : RBTree.RBNode α) →
RBTree.RBNode.below (motive := fun t => Option α → Option α → Bool) t → Option α → Option α → Bool | null | false |
LinearMap.map_algebraMap_mul | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₗ[R] B) (a : A) (r : R),
f ((algebraMap R A) r * a) = (algebraMap R B) r * f a | An alternate statement of `LinearMap.map_smul` for when `algebraMap` is more convenient to
work with than `•`. | true |
MvQPF.WEquiv.casesOn | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W α) → MvQPF.WEquiv a a_1 → Prop} {a a_1 : (MvQPF.P F).W α} (t : MvQPF.WEquiv a a_1),
(∀ (a : (MvQPF.P F).A) (f' : ((MvQPF.P F).drop.B a).Arrow α) (f₀ f₁ : (MvQPF.P F).last.B a → (MvQPF.P F).W α)
(a_2... | null | false |
Mathlib.Tactic.Ring.Common.ExtractCoeff.mk.inj | Mathlib.Tactic.Ring.Common | ∀ {e k e' : Q(ℕ)} {ve' : Mathlib.Tactic.Ring.Common.ExProdNat e'} {p : Q(«$e» = «$e'» * «$k»)} {k_1 e'_1 : Q(ℕ)}
{ve'_1 : Mathlib.Tactic.Ring.Common.ExProdNat e'_1} {p_1 : Q(«$e» = «$e'_1» * «$k_1»)},
{ k := k, e' := e', ve' := ve', p := p } = { k := k_1, e' := e'_1, ve' := ve'_1, p := p_1 } →
k = k_1 ∧ e' = e'... | null | true |
instTopologicalSpaceModelPi._aux_1 | Mathlib.Geometry.Manifold.ChartedSpace | {ι : Type u_2} → {Hi : ι → Type u_1} → [(i : ι) → TopologicalSpace (Hi i)] → TopologicalSpace (ModelPi Hi) | null | false |
ByteArray.get_set_ne._proof_2 | Batteries.Data.ByteArray | ∀ {j : ℕ} (a : ByteArray) (i : Fin a.size), ↑i < a.size | null | false |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_69 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (b : Turing.PartrecToTM2.Λ') (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ'),
b = Turing.PartrecToTM2.Λ'.read f → Turing.PartrecToTM2.Λ'.read f = b | null | false |
BoundedContinuousFunction.comp._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] {C : NNReal}
(f : BoundedContinuousFunction α β) (x y : α), ↑C * dist (f x) (f y) ≤ ↑(max C 0) * dist (f x) (f y) | null | false |
BialgCat.of_comul | Mathlib.Algebra.Category.BialgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {X : Type v} [inst_1 : Ring X] [inst_2 : Bialgebra R X],
CoalgebraStruct.comul = CoalgebraStruct.comul | null | true |
Std.HashMap.getKey?_eq_some_iff | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α}, m.getKey? k = some k' ↔ ∃ (h : k ∈ m), m.getKey k h = k' | null | true |
FirstOrder.Language.DefinableSet.instBooleanAlgebra._proof_1 | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type u_2} [inst : L.Structure M] {A : Set M} {α : Type u_1},
Function.Injective fun a => ↑a | null | false |
String.Pos.Splits.exists_eq_singleton_append_of_ne_startPos | Init.Data.String.Lemmas.Splits | ∀ {t₁ t₂ s : String} {p : s.Pos} (hp : p ≠ s.startPos),
(p.prev hp).Splits t₁ t₂ → ∃ t₂', t₂ = String.singleton ((p.prev hp).get ⋯) ++ t₂' | null | true |
Equiv.Perm.subtypePerm_apply_pow_of_mem | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {g : Equiv.Perm α} {s : Finset α} (hs : ∀ (x : α), g x ∈ s ↔ x ∈ s) {n : ℕ} {x : α} (hx : x ∈ s),
↑((g.subtypePerm hs ^ n) ⟨x, hx⟩) = (g ^ n) x | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!.match_3.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2}
(motive : Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (lrk : α)
(lrv : β lrk) (l r : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
... | null | true |
Lean.Parser.instInhabitedFirstTokens | Lean.Parser.Types | Inhabited Lean.Parser.FirstTokens | null | true |
Finset.noncommProd_commute | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (s : Finset α) (f : α → β)
(comm : (↑s).Pairwise (Function.onFun Commute f)) (y : β),
(∀ x ∈ s, Commute y (f x)) → Commute y (s.noncommProd f comm) | null | true |
AccPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop | A point `x` is an accumulation point of a filter `F` if `𝓝[≠] x ⊓ F ≠ ⊥`.
See also `ClusterPt`. | true |
SameRay.pos_smul_left | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {x y : M} {S : Type u_5} [inst_5 : CommSemiring S]
[inst_6 : PartialOrder S] [inst_7 : Algebra S R] [inst_8 : Module S M] [SMulPosMono S R] [IsScalarTow... | A positive multiple of a vector is in the same ray as one it is in the same ray as. | true |
BoxIntegral.TaggedPrepartition.casesOn | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} →
{I : BoxIntegral.Box ι} →
{motive : BoxIntegral.TaggedPrepartition I → Sort u} →
(t : BoxIntegral.TaggedPrepartition I) →
((toPrepartition : BoxIntegral.Prepartition I) →
(tag : BoxIntegral.Box ι → ι → ℝ) →
(tag_mem_Icc : ∀ (J : BoxIntegral.Box ι), tag J ∈ ... | null | false |
Filter.HasBasis.uniformity_of_nhds_zero_neg_add_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Sort u_3} {p : ι → Prop}
{U : ι → Set α}, (nhds 0).HasBasis p U → (uniformity α).HasBasis p fun i => {x | -x.2 + x.1 ∈ U i} | null | true |
WellFoundedLT.toWellFoundedRelation.eq_1 | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : LT α] [inst_1 : WellFoundedLT α],
WellFoundedLT.toWellFoundedRelation = IsWellFounded.toWellFoundedRelation fun x1 x2 => x1 < x2 | null | true |
String.Pos.toSlice_le._simp_1 | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, (p.toSlice ≤ q.toSlice) = (p ≤ q) | null | false |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_inv | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
CategoryTheory.Bicategory.whiskerRight (F.mapId a).inv (F.map f) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (F.m... | null | true |
OreLocalization.«_aux_Mathlib_GroupTheory_OreLocalization_Basic___macroRules_OreLocalization_term_-ₒ__1» | Mathlib.GroupTheory.OreLocalization.Basic | Lean.Macro | null | false |
Lean.Meta.Match.matchEqnsExt | Lean.Meta.Match.MatchEqsExt | Lean.EnvExtension Lean.Meta.Match.MatchEqnsExtState | null | true |
_private.Lean.Elab.Task.0.Lean.Elab.Tactic.TacticM.asTask.match_1 | Lean.Elab.Task | {α : Type} →
(motive : α × Lean.Elab.Tactic.State → Sort u_1) →
(x : α × Lean.Elab.Tactic.State) → ((a : α) → (s : Lean.Elab.Tactic.State) → motive (a, s)) → motive x | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Convert.0.Std.Tactic.BVDecide.LRAT.Internal.CNF.unsat_of_convertLRAT_unsat._simp_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Convert | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
AlgHom.coe_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), ⇑(f.prod g) = Function.prod ⇑f ⇑g | null | true |
PiLp.norm_toLp_const | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {p : ENNReal} {ι : Type u_2} [hp : Fact (1 ≤ p)] [inst : Fintype ι] {β : Type u_5}
[inst_1 : SeminormedAddCommGroup β],
p ≠ ⊤ → ∀ (b : β), ‖WithLp.toLp p (Function.const ι b)‖ = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖ | When `p = ∞`, this lemma does not hold without the additional assumption `Nonempty ι` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.norm_toLp_const'` for a version which exchanges the hypothesis `p ≠ ∞` for
`Nonempty ι`. | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Type | null | true |
Mathlib.Tactic.Abel.AbelMode.casesOn | Mathlib.Tactic.Abel | {motive : Mathlib.Tactic.Abel.AbelMode → Sort u} →
(t : Mathlib.Tactic.Abel.AbelMode) →
motive Mathlib.Tactic.Abel.AbelMode.term → motive Mathlib.Tactic.Abel.AbelMode.raw → motive t | null | false |
_private.Mathlib.Algebra.Lie.Abelian.0.LieSubalgebra.isLieAbelian_lieSpan_iff._simp_1_3 | Mathlib.Algebra.Lie.Abelian | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
RingHom.IsStableUnderBaseChange | Mathlib.RingTheory.RingHomProperties | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) → Prop | A morphism property `P` is `IsStableUnderBaseChange` if `P(S →+* A)` implies
`P(B →+* A ⊗[S] B)`. | true |
Filter.coprod_inf_prod_le | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g₁ g₂ : Filter β), f₁.coprod g₁ ⊓ f₂ ×ˢ g₂ ≤ f₁ ×ˢ g₂ ⊔ f₂ ×ˢ g₁ | null | true |
SSet.Subcomplex.Pairing.RankFunction.rec | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} →
{α : Type v} →
[inst : PartialOrder α] →
{motive : P.RankFunction α → Sort u_1} →
((rank : ↑P.II → α) →
(lt : ∀ {x y : ↑P.II}, P.AncestralRel x y → rank x < rank y) → motive { rank := rank, lt := lt }) →
... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.