name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.dropSlice_eq | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (xs : List α) (n m : ℕ), List.dropSlice n m xs = List.take n xs ++ List.drop (n + m) xs | null | true |
ZNum | Mathlib.Data.Num.Basic | Type | Representation of integers using trichotomy around zero.
```
13 = 1101(base 2) = pos (bit1 (bit0 (bit1 one)))
-13 = -1101(base 2) = neg (bit1 (bit0 (bit1 one)))
``` | true |
MeasureTheory.Measure._sizeOf_inst | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | (α : Type u_5) → {inst : MeasurableSpace α} → [SizeOf α] → SizeOf (MeasureTheory.Measure α) | null | false |
LucasLehmer.s.match_1 | Mathlib.NumberTheory.LucasLehmer | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((i : ℕ) → motive i.succ) → motive x | null | false |
List.dropLast_concat_getLast._f | Init.Data.List.Lemmas | ∀ {α : Type u_1} (x : List α)
(f : List.below (motive := fun x => ∀ (x_1 : x ≠ []), x.dropLast ++ [x.getLast x_1] = x) x) (x_1 : x ≠ []),
x.dropLast ++ [x.getLast x_1] = x | null | false |
PairReduction.finset_logSizeBallSeq_zero | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : TopologicalSpace T] [inst_1 : WeakPseudoEMetricSpace T] {a c : ENNReal} {J : Finset T}
[inst_2 : DecidableEq T] (hJ : J.Nonempty), (PairReduction.logSizeBallSeq J hJ a c 0).finset = J | null | true |
RingCon.ofMatrix_rel | Mathlib.LinearAlgebra.Matrix.Ideal | ∀ {R : Type u_1} {n : Type u_2} [inst : NonUnitalNonAssocSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{c : RingCon (Matrix n n R)} {x y : R}, c.ofMatrix x y ↔ ∀ (i j : n), c (Matrix.single i j x) (Matrix.single i j y) | null | true |
_private.Mathlib.Combinatorics.Additive.SmallTripling.0.Finset.small_alternating_pow_of_small_tripling._simp_1_6 | Mathlib.Combinatorics.Additive.SmallTripling | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∀ (a : α), p a) = True | null | false |
Complex.orthonormalBasisOneI | Mathlib.Analysis.InnerProductSpace.PiL2 | OrthonormalBasis (Fin 2) ℝ ℂ | `![1, I]` is an orthonormal basis for `ℂ` considered as a real inner product space. | true |
Pi.instOne.eq_1 | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {M : ι → Type u_5} [inst : (i : ι) → One (M i)], Pi.instOne = { one := fun x => 1 } | null | true |
eventually_closure_subset_of_isOpen_of_omegaLimit_subset | Mathlib.Dynamics.OmegaLimit | ∀ {τ : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] (f : Filter τ) (ϕ : τ → α → β) (s : Set α)
[CompactSpace β] {v : Set β}, IsOpen v → omegaLimit f ϕ s ⊆ v → ∃ u ∈ f, closure (Set.image2 ϕ u s) ⊆ v | null | true |
Lean.CasesAltInfo.ctorElimType | Lean.Meta.CasesInfo | {motive : Lean.CasesAltInfo → Sort u} → ℕ → Sort (max 1 u) | null | false |
Lean.Grind.CommRing.Poly.denote_mulConstC | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(k : ℤ) (p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.mulConstC k p c) =
↑k * Lean.Grind.CommRing.Poly.denote ctx p | null | true |
MeasureTheory.measureReal_abs_gt_le_integral_charFun | Mathlib.MeasureTheory.Measure.IntegralCharFun | ∀ {μ : MeasureTheory.Measure ℝ} {r : ℝ} [MeasureTheory.IsProbabilityMeasure μ],
0 < r → μ.real {x | r < |x|} ≤ 2⁻¹ * r * ‖∫ (t : ℝ) in -2 * r⁻¹..2 * r⁻¹, 1 - MeasureTheory.charFun μ t‖ | A bound on the measure of the set `{x | r < |x|}` in terms of the integral of
the characteristic function, for a probability measure on `ℝ`. | true |
_private.Batteries.Data.List.Lemmas.0.List.swap_swap._proof_1_15 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i j : ℕ} (i_1 : ℕ), i_1 = j → i + 1 ≤ (xs.swap i j).length → i < (xs.swap j i).length | null | false |
Set.notMem_Iic | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a c : α}, c ∉ Set.Iic a ↔ a < c | null | true |
PrimeSpectrum.BasicConstructibleSetData.map_n | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (φ : R →+* S)
(C : PrimeSpectrum.BasicConstructibleSetData R), (PrimeSpectrum.BasicConstructibleSetData.map φ C).n = C.n | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_smod._simp_1_7 | Init.Data.BitVec.Bitblast | ∀ {a b : ℤ}, (¬a < b) = (b ≤ a) | null | false |
CategoryTheory.ShortComplex.HasHomology.mk' | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.HomologyData), S.HasHomology | null | true |
Std.ExtDHashMap.Const.get_union_of_mem_right | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (mem : m₂.contains k = true),
Std.ExtDHashMap.Const.get (m₁.union m₂) k ⋯ = Std.ExtDHashMap.Const.get m₂ k mem | null | true |
riemannZeta_neg_two_mul_nat_add_one | Mathlib.NumberTheory.LSeries.RiemannZeta | ∀ (n : ℕ), riemannZeta (-2 * (↑n + 1)) = 0 | The trivial zeroes of the zeta function. | true |
CategoryTheory.Limits.BinaryBicone.isLimitFstKernelFork._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {c : CategoryTheory.Limits.BinaryBicone X Y} (i : CategoryTheory.Limits.IsLimit c.toCone)
(s : CategoryTheory.Limits.Fork c.fst 0),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Catego... | null | false |
Rat.cast_div | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_1} [inst : DivisionRing α] [CharZero α] (p q : ℚ), ↑(p / q) = ↑p / ↑q | null | true |
Std.Http.Request.Builder.json | Std.Http.Data.Body.Full | Std.Http.Request.Builder → String → Std.Async.Async (Std.Http.Request Std.Http.Body.Full) | Builds a request with a JSON body.
Sets `Content-Type: application/json`.
| true |
Turing.TM0.Cfg | Mathlib.Computability.TuringMachine.PostTuringMachine | (Γ : Type u_1) → Type u_2 → [Inhabited Γ] → Type (max u_1 u_2) | The configuration state of a Turing machine during operation
consists of a label (machine state), and a tape.
The tape is represented in the form `(a, L, R)`, meaning the tape looks like `L.rev ++ [a] ++ R`
with the machine currently reading the `a`. The lists are
automatically extended with blanks as the machine moves... | true |
Homotopy.comp_hom | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C₁ C₂ C₃ : HomologicalComplex V c} {f₁ g₁ : C₁ ⟶ C₂} {f₂ g₂ : C₂ ⟶ C₃} (h₁ : Homotopy f₁ g₁)
(h₂ : Homotopy f₂ g₂) (i j : ι),
(h₁.comp h₂).hom i j =
CategoryTheory.CategoryStru... | null | true |
_private.Mathlib.FieldTheory.AlgebraicClosure.0.algebraicClosure.isIntegralClosure._proof_1 | Mathlib.FieldTheory.AlgebraicClosure | ∀ (F : Type u_2) (E : Type u_1) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
IsIntegralClosure (↥(algebraicClosure F E)) F E | null | false |
NumberField.instIsTotallyRealRat | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | NumberField.IsTotallyReal ℚ | null | true |
addInvariantVectorField | Mathlib.Geometry.Manifold.GroupLieAlgebra | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{G : Type u_4} →
... | The invariant vector field associated to a vector `v` in the Lie algebra. At a
point `g`, it is given by the image of `v` under left-addition by `g`. | true |
Lean.Meta.LazyDiscrTree.PartialMatch.mk.inj | Lean.Meta.LazyDiscrTree | ∀ {todo : Array Lean.Expr} {score : ℕ} {c : Lean.Meta.LazyDiscrTree.TrieIndex} {todo_1 : Array Lean.Expr} {score_1 : ℕ}
{c_1 : Lean.Meta.LazyDiscrTree.TrieIndex},
{ todo := todo, score := score, c := c } = { todo := todo_1, score := score_1, c := c_1 } →
todo = todo_1 ∧ score = score_1 ∧ c = c_1 | null | true |
CategoryTheory.cokernelOpOp_hom | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C}
(f : X ⟶ Y),
(CategoryTheory.cokernelOpOp f).hom = CategoryTheory.Limits.cokernel.desc f.op (CategoryTheory.Limits.kernel.ι f).op ⋯ | null | true |
LucasLehmer.X.instAddCommGroup._proof_20 | Mathlib.NumberTheory.LucasLehmer | ∀ {q : ℕ}, autoParam (∀ (n : ℕ) (a : LucasLehmer.X q), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
BoundedContinuousFunction.C._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {γ : Type u_1} [inst : NormedRing γ], BoundedAdd γ | null | false |
Set.mulIndicator_mul_compl_eq_piecewise | Mathlib.Algebra.Group.Indicator | ∀ {α : Type u_1} {M : Type u_4} [inst : MulOneClass M] {s : Set α} [inst_1 : DecidablePred fun x => x ∈ s]
(f g : α → M), s.mulIndicator f * sᶜ.mulIndicator g = s.piecewise f g | null | true |
CategoryTheory.ShortComplex.HasLeftHomology.casesOn | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
{motive : S.HasLeftHomology → Sort u} →
(t : S.HasLeftHomology) → ((condition : Nonempty S.LeftHomologyData) → motive ⋯) → motive t | null | false |
IsLocalization.AtPrime.equivQuotientMapOfIsMaximal._proof_2 | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {S : Type u_2} [inst : CommRing S] (Sₚ : Type u_1) [inst_1 : CommRing Sₚ] [inst_2 : Algebra S Sₚ] (P : Ideal S),
RingHomClass (S →+* Sₚ ⧸ Ideal.map (algebraMap S Sₚ) P) S (Sₚ ⧸ Ideal.map (algebraMap S Sₚ) P) | null | false |
AddActionHom.End.add_def | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {X : Type u_4} [inst : VAdd M X] {f g : X →ₑ[id] X}, f + g = f.comp g | null | true |
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_8 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c d : CategoryTheory.Bicategory.InducedBicategory C F} (f : a ⟶ b) (g : b ⟶ c) {h h' : c ⟶ d} (η : h ⟶ h'),
CategoryTheory.Bicategory.InducedBicategory.mkHom₂
(CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategorySt... | null | false |
instMulActionRay._proof_1 | 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] {G : Type u_3} [inst_5 : Group G] [inst_6 : DistribMulAction G M]
[SMulCommClass R G M] (r : G) (x x_1 : RayVector R M),
x ≈ x_1 → SameRay R (r • ↑((R... | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.Const.alter._proof_46 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} (l' r' : Std.DTreeMap.Internal.Impl α fun x => β),
¬l'.size + r'.size ≤ l'.size + 1 + r'.size + 1 → False | null | false |
Int.associated_iff | Mathlib.Algebra.GCDMonoid.Nat | ∀ {a b : ℤ}, Associated a b ↔ a = b ∨ a = -b | null | true |
CategoryTheory.Oplax.StrongTrans.whiskerRight_naturality_comp_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.Oplax.StrongTrans F G) {a b c : B} {a' : C} (f : a ⟶ b)
(g : b ⟶ c) (h : G.obj c ⟶ a') {Z : F.obj a ⟶ a'}
(h_1 :
CategoryTheory.CategoryStruct.c... | null | true |
Aesop.instInhabitedCompleteMatch.default | Aesop.Forward.Match.Types | Aesop.CompleteMatch | null | true |
Lean.Server.ServerTask.mk.inj | Lean.Server.ServerTask | ∀ {α : Type u} {task task_1 : Task α}, { task := task } = { task := task_1 } → task = task_1 | null | true |
Finset.map_refl | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {s : Finset α}, Finset.map (Function.Embedding.refl α) s = s | null | true |
Alexandrov.projSup_map | Mathlib.Topology.Sheaves.Alexandrov | ∀ {X : Type v} [inst : TopologicalSpace X] [inst_1 : Preorder X] [inst_2 : Topology.IsUpperSet X] {ι : Type v}
(Us : ι → TopologicalSpace.Opens X)
{X_1 Y : CategoryTheory.StructuredArrow (Opposite.op (iSup Us)) (Alexandrov.principals X)} (e : X_1 ⟶ Y),
(Alexandrov.projSup Us).map e = (CategoryTheory.ObjectPropert... | null | true |
FirstOrder.Language.Embedding.mk.injEq | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(toEmbedding : M ↪ N)
(map_fun' :
autoParam
(∀ {n : ℕ} (f : L.Functions n) (x : Fin n → M),
toEmbedding.toFun (FirstOrder.Language.Structure.funMap f x) =
FirstOrder.Language.Structure.... | null | true |
FunctionField.RingOfIntegers.instFintypeClassGroupSubtypeMemSubalgebraPolynomialRingOfIntegers | Mathlib.NumberTheory.ClassNumber.FunctionField | (Fq : Type u_1) →
(F : Type u_2) →
[inst : Field Fq] →
[Fintype Fq] →
[inst_2 : Field F] →
[inst_3 : Algebra (Polynomial Fq) F] →
[inst_4 : Algebra (RatFunc Fq) F] →
[IsScalarTower (Polynomial Fq) (RatFunc Fq) F] →
[FunctionField Fq F] →
... | null | true |
Fin.add._proof_3 | Init.Data.Fin.Basic | ∀ {n : ℕ}, ∀ a < n, ∀ (b : ℕ), (a + b) % n < n | null | false |
Batteries.PairingHeapImp.Heap.WF.nil | Batteries.Data.PairingHeap | ∀ {α : Type u_1} {le : α → α → Bool}, Batteries.PairingHeapImp.Heap.WF le Batteries.PairingHeapImp.Heap.nil | It is an empty heap. | true |
MeasureTheory.VectorMeasure.map_zero | Mathlib.MeasureTheory.VectorMeasure.Operations | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : MeasurableSpace β] {M : Type u_3}
[inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M] (f : α → β), MeasureTheory.VectorMeasure.map 0 f = 0 | null | true |
Cardinal.mk_ord_toType | Mathlib.SetTheory.Ordinal.Basic | ∀ (c : Cardinal.{u_1}), Cardinal.mk c.ord.ToType = c | null | true |
Set.EqOn.comp_left | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {f₁ f₂ : α → β} {g : β → γ},
Set.EqOn f₁ f₂ s → Set.EqOn (g ∘ f₁) (g ∘ f₂) s | null | true |
balancedHull_eq_iUnion | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[NormOneClass 𝕜] (s : Set E), (balancedHull 𝕜) s = ⋃ r, ⋃ (_ : ‖r‖ ≤ 1), r • s | The balanced hull of `s` is the union of the sets `r • s`, for `r` a scalar with `‖r‖ ≤ 1`. | true |
Lake.Glob.rec | Lake.Config.Glob | {motive : Lake.Glob → Sort u} →
((a : Lean.Name) → motive (Lake.Glob.one a)) →
((a : Lean.Name) → motive (Lake.Glob.submodules a)) →
((a : Lean.Name) → motive (Lake.Glob.andSubmodules a)) → (t : Lake.Glob) → motive t | null | false |
Ideal.fg_of_isUnit | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
Function.Injective ⇑(algebraMap R P) → ∀ (I : Ideal R), IsUnit ↑I → I.FG | null | true |
AlgebraicTopology.DoldKan.QInfty_f | Mathlib.AlgebraicTopology.DoldKan.PInfty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} (n : ℕ),
AlgebraicTopology.DoldKan.QInfty.f n = (AlgebraicTopology.DoldKan.Q n).f n | null | true |
List.Pairwise.pwFilter | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] {l : List α}, List.Pairwise R l → List.pwFilter R l = l | **Alias** of the reverse direction of `List.pwFilter_eq_self`. | true |
CategoryTheory.Functor.curry₃_obj_map_app_app | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_4} {E : Type u_9} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_4} C₃]
[inst_3 : CategoryTheory.Category.{v_9, u_9} E] (X : CategoryTheory.Functor (C₁ × C₂ × C₃) E) {X_1 Y : C₁}... | null | true |
SpecialLinearGroup.congr_linearEquiv_symm | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {W : Type u_3}
[inst_3 : AddCommGroup W] [inst_4 : Module R W] (e : V ≃ₗ[R] W),
(SpecialLinearGroup.congr_linearEquiv e).symm = SpecialLinearGroup.congr_linearEquiv e.symm | null | true |
_private.Mathlib.Order.OrderIsoNat.0.exists_increasing_or_nonincreasing_subseq'._proof_1_5 | Mathlib.Order.OrderIsoNat | ∀ (m n n' : ℕ), n + m < n' → n + n' - n - m + m = n' | null | false |
Lean.Meta.Hypothesis.noConfusion | Lean.Meta.Tactic.Assert | {P : Sort u} → {t t' : Lean.Meta.Hypothesis} → t = t' → Lean.Meta.Hypothesis.noConfusionType P t t' | null | false |
SetRel.comp_eq_self | Mathlib.Basic.Rel | ∀ {α : Type u_1} {R : SetRel α α} [R.IsRefl] [R.IsTrans], R.comp R = R | null | true |
AffineMap.comp_lineMap | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
[inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2] (f : P1 →ᵃ[k] P2) (p₀ p₁ : P1),
f.comp (AffineMap.lineMap p₀ p₁... | null | true |
fixedPoints.completeLattice | Mathlib.Order.FixedPoints | {α : Type u} → [inst : CompleteLattice α] → (f : α →o α) → CompleteLattice ↑(Function.fixedPoints ⇑f) | **Knaster-Tarski Theorem**: The fixed points of `f` form a complete lattice. | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_or_lt_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a = b) = (a.toNat = b.toNat) | null | false |
Lean.PersistentHashMap.IsEntriesNode.mk | Lean.Data.PersistentHashMap | ∀ {α : Type u_1} {β : Type u_2} (entries : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))),
Lean.PersistentHashMap.IsEntriesNode (Lean.PersistentHashMap.Node.entries entries) | null | true |
Lean.Meta.Grind.Arith.CollectDecVars.State.mk | Lean.Meta.Tactic.Grind.Arith.Util | Std.HashSet UInt64 → Lean.FVarIdSet → Lean.Meta.Grind.Arith.CollectDecVars.State | null | true |
CategoryTheory.isCommAddMonObj_iff_isAddCommutative | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.BraidedCategory C],
CategoryTheory.IsCommAddMonObj M ↔ ∀ (X : C), IsAddCommutative (X ⟶ M) | An additive monoid object `M` is commutative if and only if `X ⟶ M` is commutative for all
`X`. | true |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.extract.match_1.eq_1 | Batteries.Data.String.Lemmas | ∀ (motive : String → String.Pos.Raw → String.Pos.Raw → Sort u_1) (s : String) (b e : String.Pos.Raw)
(h_1 : (s : String) → (b e : String.Pos.Raw) → motive s b e),
(match s, b, e with
| s, b, e => h_1 s b e) =
h_1 s b e | null | true |
Std.Slice.iter | Std.Data.Iterators.Producers.Slice | {γ : Type u_1} → {α β : Type u_2} → [Std.ToIterator (Std.Slice γ) Id α β] → Std.Slice γ → Std.Iter β | Returns an iterator over the given slice. This iterator will emit the elements of the slice
in increasing order of the indices.
| true |
CategoryTheory.Pretriangulated.Opposite.OpOpCommShift.iso_inv_app | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : C) (n m : ℤ)
(hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.OpOpCommShift.iso_inv_app._auto_1),
(CategoryTheory.Pretriangulated.Opposite.OpOpCommShift.iso C n).inv.app X =
CategoryThe... | null | true |
_private.Mathlib.Data.Part.0.Part.mem_right_unique.match_1_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (motive : (x : α) → (x_1 x_2 : Part α) → x ∈ x_1 → x ∈ x_2 → Prop) (x : α) (x_1 x_2 : Part α)
(x_3 : x ∈ x_1) (x_4 : x ∈ x_2),
(∀ (x : α) (x_5 x_6 : Part α) (ho : x_5.Dom) (h : x_5.get ho = x) (hp : x_6.Dom) (h_1 : x_6.get hp = x),
motive x x_5 x_6 ⋯ ⋯) →
motive x x_1 x_2 x_3 x_4 | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Equiv.0.MvPowerSeries.optionEquivLeft._proof_4 | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ (σ : Type u_1) (R : Type u_2) [inst : CommSemiring R] (r : R),
MvPowerSeries.optionFunLeft✝ σ R ((algebraMap R (MvPowerSeries (Option σ) R)) r) =
(algebraMap R (PowerSeries (MvPowerSeries σ R))) r | null | false |
ZFSet.card_powerset | Mathlib.SetTheory.ZFC.Cardinal | ∀ (x : ZFSet.{u}), x.powerset.card = 2 ^ x.card | null | true |
Std.Time.Second.instOrdOrdinal | Std.Time.Time.Unit.Second | {leap : Bool} → Ord (Std.Time.Second.Ordinal leap) | null | true |
Finset.inter_assoc | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ s₃ : Finset α), s₁ ∩ s₂ ∩ s₃ = s₁ ∩ (s₂ ∩ s₃) | null | true |
Multiset.dedup_add | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), (s + t).dedup = s.ndunion t.dedup | null | true |
String.Slice.Pos.toReplaceEnd | Init.Data.String.Basic | {s : String.Slice} → (p₀ pos : s.Pos) → pos ≤ p₀ → (s.sliceTo p₀).Pos | null | true |
_private.Mathlib.Analysis.Complex.Liouville.0.Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le._simp_1_2 | Mathlib.Analysis.Complex.Liouville | ∀ (n : ℕ), (n.factorial = 0) = False | null | false |
BooleanAlgebra.ofRegular._proof_3 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (x y : α), x ⊓ yᶜ = x ⊓ yᶜ | null | false |
Std.Iter.Partial.instForIn' | Init.Data.Iterators.Consumers.Loop | {α β : Type w} →
{n : Type x → Type x'} →
[Monad n] →
[inst : Std.Iterator α Id β] →
[Std.IteratorLoop α Id n] →
ForIn' n (Std.Iter.Partial β) β { mem := fun it out => it.it.IsPlausibleIndirectOutput out } | An implementation of `for h : ... in ... do ...` notation for partial iterators.
| true |
ProbabilityTheory.Kernel.HasSubgaussianMGF.ae_eq_zero_of_hasSubgaussianMGF_zero_of_measurable | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {Ω' : Type u_2} {mΩ : MeasurableSpace Ω} {mΩ' : MeasurableSpace Ω'} {ν : MeasureTheory.Measure Ω'}
{κ : ProbabilityTheory.Kernel Ω' Ω} {X : Ω → ℝ},
Measurable X → ProbabilityTheory.Kernel.HasSubgaussianMGF X 0 κ ν → X =ᵐ[ν.bind ⇑κ] 0 | Auxiliary lemma for `ae_eq_zero_of_hasSubgaussianMGF_zero'`. | true |
Matrix.SpecialLinearGroup.row_ne_zero | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] [Nontrivial R]
(g : Matrix.SpecialLinearGroup n R) (i : n), ↑g i ≠ 0 | null | true |
CategoryTheory.ShortComplex.exact_and_mono_f_iff_f_is_kernel | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) [CategoryTheory.Balanced C] [S.HasHomology],
S.Exact ∧ CategoryTheory.Mono S.f ↔
Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯)) | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjComp._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_5} {B : Type u_6} {C : Type u_7} [inst : CategoryTheory.Category.{u_1, u_5} A]
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] [inst_2 : CategoryTheory.Category.{u_3, u_7} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u_9} {Y : Type u_12} {Z : Type u_8}
[inst_3 : Cat... | null | false |
_private.Lean.Syntax.0.Lean.Syntax.hasIdent.match_1 | Lean.Syntax | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(id' : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive (Lean.Syntax.ident info rawVal id' preresolved)) →
((info : Lean.SourceInfo) →
(kin... | null | false |
Nucleus.coe_top | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : SemilatticeInf X] [inst_1 : OrderTop X], ⇑⊤ = ⊤ | null | true |
Nat.choose._sunfold | Mathlib.Data.Nat.Choose.Basic | ℕ → ℕ → ℕ | null | false |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.instField._simp_9 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : Zero Γ] [inst_1 : PartialOrder Γ] [inst_2 : Zero R] [inst_3 : IntCast R]
(z : ℤ), ↑z = (HahnSeries.single 0) ↑z | null | false |
_private.Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape.0.CategoryTheory.ObjectProperty.isClosedUnderLimitsOfShape_iff_of_equivalence._simp_1_1 | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J], P.IsClosedUnderLimitsOfShape J = (P.limitsOfShape J ≤ P) | null | false |
VAdd.comp.vadd.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_5} [inst : VAdd M α] (g : N → M) (n : N) (a : α),
VAdd.comp.vadd g n a = g n +ᵥ a | null | true |
upperHemicontinuousOn_iff_preimage_Iic | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f : α → Set β} {s : Set α} [inst_1 : TopologicalSpace β],
UpperHemicontinuousOn f s ↔ ∀ x ∈ s, ∀ u ∈ nhdsSet (f x), f ⁻¹' Set.Iic u ∈ nhdsWithin x s | null | true |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_ae_parallelepiped._simp_1_5 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
CategoryTheory.Comon.Hom.mk.injEq | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Comon C} (hom : M.X ⟶ N.X) [isComonHom_hom : CategoryTheory.IsComonHom hom] (hom_1 : M.X ⟶ N.X)
(isComonHom_hom_1 : CategoryTheory.IsComonHom hom_1),
({ hom := hom, isComonHom_hom := isCo... | null | true |
Ordinal.lt_omega0_opow_succ | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a b : Ordinal.{u_1}}, a < Ordinal.omega0 ^ Order.succ b ↔ ∃ n, a < Ordinal.omega0 ^ b * ↑n | null | true |
Pi.default_apply | Mathlib.Basic.Unique | ∀ {α : Sort u_1} {β : α → Sort v} [inst : (a : α) → Inhabited (β a)] (a : α), default a = default | null | true |
_private.Lean.DefEqAttrib.0.Lean.defeqAttr._regBuiltin.Lean.defeqAttr.declRange_3 | Lean.DefEqAttrib | IO Unit | null | false |
ContinuousOrderHom.coe_id | Mathlib.Topology.Order.Hom.Basic | ∀ (α : Type u_2) [inst : TopologicalSpace α] [inst_1 : Preorder α], ⇑(ContinuousOrderHom.id α) = id | null | true |
Topology.RelCWComplex.cellFrontier.eq_1 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D] (n : ℕ)
(i : Topology.RelCWComplex.cell C n),
Topology.RelCWComplex.cellFrontier n i = ↑(Topology.RelCWComplex.map n i) '' Metric.sphere 0 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.