name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PadicSeq.norm.eq_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p),
f.norm = if hf : f ≈ 0 then 0 else padicNorm p (↑f (PadicSeq.stationaryPoint hf)) | null | true |
Std.DTreeMap.Internal.Const.instSliceableImplRciSlice | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.Rci.Sliceable (Std.DTreeMap.Internal.Impl α fun x => β) α (Std.DTreeMap.Internal.Const.RciSlice α β) | null | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.induct_rco_right._proof_1_3 | Init.Data.Range.Polymorphic.IntLemmas | ∀ (d : ℕ) (a b : ℤ), (b - a).toNat = d + 1 → ¬a ≤ b - 1 → False | null | false |
Polynomial.cyclotomic_eq_prod_X_sub_primitiveRoots | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {K : Type u_1} [inst : CommRing K] [inst_1 : IsDomain K] {ζ : K} {n : ℕ},
IsPrimitiveRoot ζ n → Polynomial.cyclotomic n K = ∏ μ ∈ primitiveRoots n K, (Polynomial.X - Polynomial.C μ) | If there is a primitive `n`-th root of unity in `K`, then
`cyclotomic n K = ∏ μ ∈ primitiveRoots n K, (X - C μ)`. ∈ particular,
`cyclotomic n K = cyclotomic' n K` | true |
_private.Lean.Attributes.0.Lean.registerParametricAttributeExt.match_1 | Lean.Attributes | {α : Type} →
(motive : List Lean.Name × Lean.NameMap α → Sort u_1) →
(x : List Lean.Name × Lean.NameMap α) →
((decls : List Lean.Name) → (m : Lean.NameMap α) → motive (decls, m)) → motive x | null | false |
FirstOrder.Language.Term.subst._f | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} →
{β : Type v'} →
(x : L.Term α) →
FirstOrder.Language.Term.below (motive := fun x => (α → L.Term β) → L.Term β) x → (α → L.Term β) → L.Term β | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.Over.0.CategoryTheory.Over.isMonHom_pullbackFst_id_right._simp_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | null | false |
ack_pair_lt | Mathlib.Computability.Ackermann | ∀ (m n k : ℕ), ack m (Nat.pair n k) < ack (m + 4) (max n k) | null | true |
nhdsNE_le_cofinite | Mathlib.Topology.Separation.Basic | ∀ {α : Type u_3} [inst : TopologicalSpace α] [T1Space α] (a : α), nhdsWithin a {a}ᶜ ≤ Filter.cofinite | null | true |
ULift.divisionRing._proof_9 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : DivisionRing α] (x : ℚ≥0) (x_1 : ULift.{u_1, u_2} α),
{ down := DivisionSemiring.nnqsmul x x_1.down } = { down := (↑x).down * x_1.down } | null | false |
WellFounded.fix' | Mathlib.Order.RelClasses | {α : Type u} →
(r : α → α → Prop) →
[i : WellFounded r] →
{motive : α → Sort u_1} → ((x : α) → ((y : α) → r y x → motive y) → motive x) → (x : α) → motive x | Creates data, given a way to generate a value from all that compare as less under a well-founded
relation. See also `WellFounded.fix_eq`. | true |
Projectivization.cross_comm | Mathlib.LinearAlgebra.Projectivization.Constructions | ∀ {F : Type u_1} [inst : Field F] [inst_1 : DecidableEq F] (v w : Projectivization F (Fin 3 → F)), v.cross w = w.cross v | null | true |
Polynomial.mirror_smul | Mathlib.Algebra.Polynomial.Mirror | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) [NoZeroDivisors R] (a : R), (a • p).mirror = a • p.mirror | null | true |
FirstOrder.Language.Theory.Imp.instReflBoundedFormula | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {n : ℕ}, Std.Refl T.Imp | null | true |
LinearMap.BilinForm.tensorDistribEquiv | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | (R : Type uR) →
{M₁ : Type uM₁} →
{M₂ : Type uM₂} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M₁] →
[inst_2 : AddCommGroup M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
[Module.Projective R M₁] →
[Module.Finite R M₁] ... | `tensorDistrib` as an equivalence. | true |
Polynomial.instMulSemiringAction | Mathlib.Algebra.Polynomial.GroupRingAction | (M : Type u_1) →
[inst : Monoid M] →
(R : Type u_2) → [inst_1 : Semiring R] → [MulSemiringAction M R] → MulSemiringAction M (Polynomial R) | null | true |
Nat.toList_rco_add_right_eq_map | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m...m + n).toList = List.map (fun x => x + m) (0...n).toList | null | true |
QuadraticAlgebra.instAddGroup._proof_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : AddGroup R] (a_1 : QuadraticAlgebra R a b), -a_1 + a_1 = 0 | null | false |
CategoryTheory.PreGaloisCategory.instIsTopologicalGroupAutFunctorFintypeCat | Mathlib.CategoryTheory.Galois.Topology | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat),
IsTopologicalGroup (CategoryTheory.Aut F) | null | true |
Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal._sizeOf_inst | Mathlib.Tactic.IntervalCases | SizeOf Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal | null | false |
Summable.tsum_eq_add_tsum_ite | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α] [IsTopologicalAddGroup α]
{f : β → α} [T2Space α] [inst_4 : DecidableEq β],
Summable f → ∀ (b : β), ∑' (n : β), f n = f b + ∑' (n : β), if n = b then 0 else f n | Let `f : β → α` be a summable function and let `b ∈ β` be an index.
Lemma `tsum_eq_add_tsum_ite` writes `Σ' n, f n` as `f b` plus the sum of the
remaining terms. | true |
Subring.instInfSet._proof_3 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : NonAssocRing R] (s : Set (Subring R)), ↑(⨅ t ∈ s, t.toAddSubgroup) = ⋂ t ∈ s, ↑t | null | false |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuous_lintegral._simp_1_1 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | null | false |
CategoryTheory.Limits.map_lift_piComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : β → C)
[inst_2 : CategoryTheory.Limits.HasProduct f] [inst_3 : CategoryTheory.Limits.HasProduct fun b => G.obj (f b)] (P : C)
(g : (j : β) → P ⟶ f... | null | true |
Rep.instIsTrivialTrivial | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Ring k] [inst_1 : Monoid G] {V : Type w} [inst_2 : AddCommGroup V]
[inst_3 : Module k V], (Rep.trivial k G V).IsTrivial | null | true |
CartanMatrix.E₇_det | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | (CartanMatrix.E 7).det = 2 | null | true |
Nat.lcm_le_mul | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, 0 < m → 0 < n → m.lcm n ≤ m * n | null | true |
LieSubalgebra.coe_toLieSubmodule | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L),
↑K.toLieSubmodule = K.toSubmodule | null | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.mod_le.match_1_3 | Init.Data.Nat.Div.Basic | ∀ (y : ℕ) (motive : y = 0 ∨ y > 0 → Prop) (x : y = 0 ∨ y > 0),
(∀ (h₂ : y = 0), motive ⋯) → (∀ (h₂ : y > 0), motive ⋯) → motive x | null | false |
DirectSum.GCommSemiring.noConfusion | Mathlib.Algebra.DirectSum.Ring | {P : Sort u} →
{ι : Type u_1} →
{A : ι → Type u_2} →
{inst : AddCommMonoid ι} →
{inst_1 : (i : ι) → AddCommMonoid (A i)} →
{t : DirectSum.GCommSemiring A} →
{ι' : Type u_1} →
{A' : ι' → Type u_2} →
{inst' : AddCommMonoid ι'} →
{in... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorBinaryRefVecBlastSub | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.BinaryRefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastSub | null | true |
RingQuot.preLiftAlgHom.congr_simp | Mathlib.Algebra.RingQuot | ∀ (S : Type u_1) [inst : CommSemiring S] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra S A] {B : Type u_3}
[inst_3 : Semiring B] [inst_4 : Algebra S B] {s : A → A → Prop} {f f_1 : A →ₐ[S] B} (e_f : f = f_1)
(h : ∀ ⦃x y : A⦄, s x y → f x = f y), RingQuot.preLiftAlgHom S h = RingQuot.preLiftAlgHom S ⋯ | null | true |
SimpleGraph.extremalNumber | Mathlib.Combinatorics.SimpleGraph.Extremal.Basic | ℕ → {W : Type u_1} → SimpleGraph W → ℕ | The extremal number of a natural number `n` and a simple graph `H` is the maximum number of
edges in a `H`-free simple graph on `n` vertices.
If `H` is contained in all simple graphs on `n` vertices, then this is `0`. | true |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_self'._proof_4 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} (i : ι),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (X i)) (f i) = f i | null | false |
strictMonoOn_toDual_comp_iff | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictMonoOn (⇑OrderDual.toDual ∘ f) s ↔ StrictAntiOn f s | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Bound.0.Mathlib.Meta.Positivity.evalInitialBound.match_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | {u : Lean.Level} →
{α : Q(Type u)} →
(motive : Option Q(PartialOrder «$α») → Sort u_1) →
(pα? : Option Q(PartialOrder «$α»)) →
(Unit → motive none) → ((val : Q(PartialOrder «$α»)) → motive (some val)) → motive pα? | null | false |
Lean.StructureInfo._sizeOf_inst | Lean.Structure | SizeOf Lean.StructureInfo | null | false |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.withBRecOnArgs.go.go2._unary._proof_1 | Lean.Meta.IndPredBelow | ∀ (minorArgs : Array Lean.Expr) (j : ℕ) (vars args : Array Lean.Expr),
j < minorArgs.size →
∀ (newIH proof : Lean.Expr),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun j vars => PSigma.casesOn vars fun vars args => minorArgs.size - j)
⟨j + 1, ⟨vars.push newIH, (args.push newI... | null | false |
Submodule.mem_biSup_iff_exists_dfinsupp | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {N : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N]
[inst_3 : DecidableEq ι] (p : ι → Prop) [inst_4 : DecidablePred p] (S : ι → Submodule R N) (x : N),
x ∈ ⨆ i, ⨆ (_ : p i), S i ↔ ∃ f, ((DFinsupp.lsum ℕ) fun i => (S i).subtype) (DFinsupp.filter p f) = ... | null | true |
Asymptotics.IsEquivalent.tendsto_nhds_iff | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α} {c : β},
Asymptotics.IsEquivalent l u v → (Filter.Tendsto u l (nhds c) ↔ Filter.Tendsto v l (nhds c)) | null | true |
Set.Ioc_top | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, Set.Ioc a ⊤ = Set.Ioi a | null | true |
WithZero.instExistsAddOfLE | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Add α] [ExistsAddOfLE α], ExistsAddOfLE (WithZero α) | null | true |
Lean.Elab.ConfigEval.EvalConfigItemHandler.ref | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Lean.Elab.ConfigEval.EvalConfigItemHandler → Lean.Syntax | Ref for the key. | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.prod_range_div_prod_range._simp_1_3 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Matrix.instModuleForall._proof_1 | Mathlib.LinearAlgebra.Matrix.Action | ∀ {n : Type u_1} {R : Type u_2} [inst : Fintype n] [inst_1 : Semiring R] (x x_1 : Matrix n n R) (x_2 : n → R),
(x * x_1).mulVec x_2 = x.mulVec (x_1.mulVec x_2) | null | false |
ENNReal.HolderConjugate.ne_zero | Mathlib.Basic.ENNReal.Holder | ∀ (p q : ENNReal) [p.HolderConjugate q], p ≠ 0 | null | true |
Std.DTreeMap.Internal.Impl.getKey?_insert_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k : α} {v : β k}, (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.getKey? k = some k | null | true |
WithTop.coe_sSup._simp_1 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α}, BddAbove s → ⨆ a ∈ s, ↑a = ↑(sSup s) | null | false |
Finset.sup'_mono | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] (f : β → α) {s₁ s₂ : Finset β} (h : s₁ ⊆ s₂)
(h₁ : s₁.Nonempty), s₁.sup' h₁ f ≤ s₂.sup' ⋯ f | null | true |
Turing.ToPartrec.Cfg.ret.inj | Mathlib.Computability.TuringMachine.Config | ∀ {a : Turing.ToPartrec.Cont} {a_1 : List ℕ} {a_2 : Turing.ToPartrec.Cont} {a_3 : List ℕ},
Turing.ToPartrec.Cfg.ret a a_1 = Turing.ToPartrec.Cfg.ret a_2 a_3 → a = a_2 ∧ a_1 = a_3 | null | true |
Nat.testBit_eq_inth | Mathlib.Data.Nat.Bitwise | ∀ (n i : ℕ), n.testBit i = n.bits.getI i | The ith bit is the ith element of `n.bits`. | true |
CategoryTheory.Pretriangulated.Triangle.ctorIdx | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.HasShift C ℤ} → CategoryTheory.Pretriangulated.Triangle C → ℕ | null | false |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.AbstractM.State.mk | Lean.Meta.Tactic.Grind.ProveEq | Std.HashMap (Lean.Expr × Lean.Expr) Lean.Expr →
Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.AbstractM.State✝ | null | true |
Filter.eventuallyEqSet_univ._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α} {l : Filter α}, (s =ᶠ[l] Set.univ) = (s ∈ l) | null | false |
Int16.toInt32_ne_neg_one | Init.Data.SInt.Lemmas | ∀ (a : Int16), a ≠ -1 → a.toInt32 ≠ -1 | null | true |
AlgebraicGeometry.Scheme.RationalMap.fromFunctionField_ofFunctionField | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y S : AlgebraicGeometry.Scheme} (sX : X ⟶ S) (sY : Y ⟶ S) [inst : AlgebraicGeometry.IsIntegral X]
[inst_1 : AlgebraicGeometry.LocallyOfFiniteType sY] (f : AlgebraicGeometry.Spec X.functionField ⟶ Y)
(h :
CategoryTheory.CategoryStruct.comp f sY =
CategoryTheory.CategoryStruct.comp (X.fromSpecStalk (ge... | null | true |
Lean.CodeAction.CommandCodeActionEntry._sizeOf_1 | Lean.Server.CodeActions.Attr | Lean.CodeAction.CommandCodeActionEntry → ℕ | null | false |
Std.Slice.Internal.SubarrayData.start_le_stop | Init.Data.Array.Subarray | ∀ {α : Type u} (self : Std.Slice.Internal.SubarrayData α), self.start ≤ self.stop | The starting index is no later than the ending index.
The ending index is exclusive. If the starting and ending indices are equal, then the subarray is
empty.
| true |
Lean.Elab.Tactic.Try.Ctx.originalMaxHeartbeats | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.Ctx → ℕ | null | true |
Continuous.finset_sup' | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} {X : Type u_2} [inst : TopologicalSpace L] [inst_1 : TopologicalSpace X] {ι : Type u_3}
[inst_2 : SemilatticeSup L] [ContinuousSup L] {s : Finset ι} {f : ι → X → L} (hne : s.Nonempty),
(∀ i ∈ s, Continuous (f i)) → Continuous (s.sup' hne f) | null | true |
Set.Icc_sdiff_right | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, Set.Icc b a \ {a} = Set.Ico b a | null | true |
Ideal.Quotient.field._proof_10 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) [inst_1 : I.IsMaximal],
autoParam (∀ (q : ℚ), ↑q = ↑q.num / ↑q.den) DivisionRing.ratCast_def._autoParam | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
ImportGraph.WorkspaceModel.Module.recOn | ImportGraph.WorkspaceModel.Model | {motive : ImportGraph.WorkspaceModel.Module → Sort u} →
(t : ImportGraph.WorkspaceModel.Module) →
((toModuleHeader : Lean.ModuleHeader) →
(name : Lean.Name) →
(srcFile : System.FilePath) →
(isPrelude : Bool) →
(transDeps : ImportGraph.Shake.Provides) →
(... | null | false |
ULower.down_eq_down._simp_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} [inst : Encodable α] {a b : α}, (ULower.down a = ULower.down b) = (a = b) | null | false |
MeasureTheory.SimpleFunc.instCommMonoid._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : CommMonoid β] (a b : MeasureTheory.SimpleFunc α β),
a * b = b * a | null | false |
Lean.Expr.updateForallS! | Lean.Meta.Sym.AlphaShareBuilder | {m : Type → Type} →
[Lean.Meta.Sym.Internal.MonadShareCommon m] → [Monad m] → Lean.Expr → Lean.Expr → Lean.Expr → m Lean.Expr | null | true |
Matrix.linftyOpSeminormedAddCommGroup._proof_9 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : SeminormedAddCommGroup α],
((⨅ i, UniformSpace.comap (Function.eval i) PseudoEMetricSpace.toUniformSpace).toCore.uniformity.lift' fun s =>
SetRel.comp s s) ≤
(⨅ i, UniformSpace.comap (Function.eval i) PseudoEMetricSpace.toUniformSpa... | null | false |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_size_left_le_start._proof_1_8 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {i j : ℕ} {a b : Array α},
a.size ≤ i → a.extract i j ++ b.extract (i - a.size) (j - a.size) = b.extract (i - a.size) (j - a.size) | null | false |
Set.Ici_subset_Ioi._simp_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (Set.Ici a ⊆ Set.Ioi b) = (b < a) | null | false |
Real.sin_two_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.sin (2 * Real.pi - x) = -Real.sin x | null | true |
EuclideanGeometry.Sphere.radius | Mathlib.Geometry.Euclidean.Sphere.Basic | {P : Type u_2} → [inst : MetricSpace P] → EuclideanGeometry.Sphere P → ℝ | radius of the sphere; not required to be positive | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.reduceBneDiff._regBuiltin.Nat.reduceBneDiff.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.3606884043._hygCtx._hyg.31 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
OrderDual.instSubtractionMonoid._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (x : αᵒᵈ), - -x = x | null | false |
BitVec.divRec._f | Init.Data.BitVec.Bitblast | {w : ℕ} →
BitVec.DivModArgs w →
(m : ℕ) →
Nat.below (motive := fun m => BitVec.DivModState w → BitVec.DivModState w) m →
BitVec.DivModState w → BitVec.DivModState w | null | false |
Module.End.IsSemisimple.pow | Mathlib.LinearAlgebra.Semisimple | ∀ {M : Type u_2} [inst : AddCommGroup M] {K : Type u_3} [inst_1 : Field K] [inst_2 : Module K M] {f : Module.End K M}
[FiniteDimensional K M], f.IsSemisimple → ∀ (n : ℕ), (f ^ n).IsSemisimple | null | true |
Affine.Triangle.orthocenter_mem_affineSpan | Mathlib.Geometry.Euclidean.MongePoint | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P), t.orthocenter ∈ affineSpan ℝ (Set.range t.points) | The orthocenter lies in the affine span. | true |
ISize.xor_self | Init.Data.SInt.Bitwise | ∀ {a : ISize}, a ^^^ a = 0 | null | true |
List.head! | Init.Data.List.BasicAux | {α : Type u_1} → [Inhabited α] → List α → α | Returns the first element in the list. If the list is empty, panics and returns `default`.
Safer alternatives include:
* `List.head`, which requires a proof that the list is non-empty,
* `List.head?`, which returns an `Option`, and
* `List.headD`, which returns an explicitly-provided fallback value on empty lists.
| true |
_private.Init.Data.List.Impl.0.List.setTR.go.match_1.eq_3 | Init.Data.List.Impl | ∀ {α : Type u_1} (motive : List α → ℕ → Array α → Sort u_2) (x : α) (xs : List α) (n : ℕ) (acc : Array α)
(h_1 : (x : ℕ) → (x_1 : Array α) → motive [] x x_1)
(h_2 : (head : α) → (xs : List α) → (acc : Array α) → motive (head :: xs) 0 acc)
(h_3 : (x : α) → (xs : List α) → (n : ℕ) → (acc : Array α) → motive (x :: x... | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic.0.NumberField.mixedEmbedding.mem_span_latticeBasis._simp_1_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
ManyOneDegree.instPartialOrder._private_1 | Mathlib.Computability.Reduce | ∀ (d : ManyOneDegree), d ≤ d | null | false |
SimpleGraph.Embedding.toCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} → {W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → H ↪g G → H.Copy G | An embedding gives rise to a copy. | true |
DFinsupp.sigmaCurry_apply | Mathlib.Data.DFinsupp.Sigma | ∀ {ι : Type u} {α : ι → Type u_1} {δ : (i : ι) → α i → Type v} [inst : DecidableEq ι]
[inst_1 : (i : ι) → (j : α i) → Zero (δ i j)] (f : Π₀ (i : (x : ι) × α x), δ i.fst i.snd) (i : ι) (j : α i),
(f.sigmaCurry i) j = f ⟨i, j⟩ | null | true |
Nat.minSqFac | Mathlib.Data.Nat.Squarefree | ℕ → Option ℕ | Returns the smallest prime factor `p` of `n` such that `p^2 ∣ n`, or `none` if there is no
such `p` (that is, `n` is squarefree). See also `Nat.squarefree_iff_minSqFac`. | true |
MeasurableSet.Subtype.instSDiff | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | {α : Type u_1} → [inst : MeasurableSpace α] → SDiff (Subtype MeasurableSet) | null | true |
NumberField.mixedEmbedding.fundamentalCone.preimageOfMemIntegerSet_mixedEmbedding | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {x : NumberField.RingOfIntegers K}
(hx : (NumberField.mixedEmbedding K) ↑x ∈ NumberField.mixedEmbedding.fundamentalCone.integerSet K),
↑(NumberField.mixedEmbedding.fundamentalCone.preimageOfMemIntegerSet ⟨(NumberField.mixedEmbedding K) ↑x, hx⟩) = x | null | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorLoop.loop.wf._unary._proof_4 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] (LargeEnough : α → Prop),
(∀ (a b : α), a ≤ b → LargeEnough a → LargeEnough b) →
∀ (next : α), LargeEnough next → ∀ (next' : α), Std.PRange.succ? next = some next... | null | false |
_private.Mathlib.Analysis.Calculus.IteratedDeriv.FaaDiBruno.0.iteratedDeriv_comp_two._simp_1_2 | Mathlib.Analysis.Calculus.IteratedDeriv.FaaDiBruno | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F}, deriv f = derivWithin f Set.univ | null | false |
OrthogonalIdempotents.map_injective_iff | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) {I : Type u_3} {e : I → R},
Function.Injective ⇑f → (OrthogonalIdempotents (⇑f ∘ e) ↔ OrthogonalIdempotents e) | null | true |
Graph.IsLink.right_mem | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, G.IsLink e x y → y ∈ G.vertexSet | null | true |
IO.Error.protocolError | Init.System.IOError | UInt32 → String → IO.Error | A protocol error occurred.
This corresponds to the POSIX errors `EPROTO`, `EPROTONOSUPPORT`, and `EPROTOTYPE`.
| true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.isSemilinearSet_setOfFloorNeg | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι],
IsSemilinearSet (IsProperLinearSet.setOfFloorNeg✝ hs) | null | true |
CategoryTheory.Limits.FormalCoproduct.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Limits.FormalCoproduct C}
[inst_1 : SizeOf C] (f : X.I → Y.I) (φ : (i : X.I) → X.obj i ⟶ Y.obj (f i)), sizeOf { f := f, φ := φ } = 1 | null | true |
IsUnit.smul_eq_zero._simp_1 | Mathlib.Algebra.GroupWithZero.Action.Units | ∀ {G : Type u_2} {M : Type u_3} [inst : Monoid G] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction G M] {u : G}
{x : M}, IsUnit u → (u • x = 0) = (x = 0) | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_8 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {R : Type u} {Γ₀ : Type v} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀) (r : R),
(v r ≤ 1) = (r ∈ v.integer) | null | false |
SingularManifold.sum_f | Mathlib.Geometry.Manifold.Bordism | ∀ {X : Type u_1} [inst : TopologicalSpace X] {k : WithTop ℕ∞} {E : Type u_4} {H : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : FiniteDimensional ℝ E]
[inst_4 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} (s : SingularManifold X k I) (t : SingularManifold X k I),
(s.sum t).f ... | null | true |
MulEquiv.coprodAssoc_symm_apply_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P] (x : M),
(MulEquiv.coprodAssoc M N P).symm (Monoid.Coprod.inl x) = Monoid.Coprod.inl (Monoid.Coprod.inl x) | null | true |
CategoryTheory.Subgroupoid.instCompleteLattice._proof_4 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_1} [inst : CategoryTheory.Groupoid C] (x x_1 x_2 : CategoryTheory.Subgroupoid C),
x ≤ x_1 →
x ≤ x_2 → ∀ x_3 ∈ x, x_3.snd.snd ∈ x_1.arrows x_3.fst x_3.snd.fst ∧ x_3.snd.snd ∈ x_2.arrows x_3.fst x_3.snd.fst | null | false |
Std.ExtDTreeMap.getKey_maxKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km : α} {hc : t.contains km = true}, t.maxKey?.get ⋯ = km → t.getKey km hc = km | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.