name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
selfAdjoint.instField._proof_12 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (x : ℤ), ↑↑x = ↑↑x |
WithBot.map_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] {β : Type u_1} (f : α → β), WithBot.map f 0 = ↑(f 0) |
ZeroHom.instModule._proof_1 | Mathlib.Algebra.Module.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (r : R), r • 0 = 0 |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.map_add_toList_rcc._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {n k : ℤ}, ¬n + 1 + k = n + k + 1 → False |
ConvexOn.lt_left_of_right_lt' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : Module 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConvexOn 𝕜 s f →
∀ {x y : E},
x ∈ s → y ∈ s → ∀ {a b : 𝕜}, 0 < a → 0 < b → a + b = 1 → f y < f (a • x + b • y) → f (a • x + b • y) < f x |
Except.ctorIdx | Init.Prelude | {ε : Type u} → {α : Type v} → Except ε α → ℕ |
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_2 | Mathlib.Algebra.Divisibility.Prod | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
AlgebraicGeometry.Scheme.basicOpen_le | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (f : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen f ≤ U |
CategoryTheory.Precoverage.mem_coverings_of_isIso | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.Precoverage C} [self : J.HasIsos] {S T : C}
(f : S ⟶ T) [CategoryTheory.IsIso f], CategoryTheory.Presieve.singleton f ∈ J.coverings T |
Primrec.PrimrecBounded | Mathlib.Computability.Primrec.Basic | {α : Type u_1} → {β : Type u_2} → [Primcodable α] → [Primcodable β] → (α → β) → Prop |
Order.Ideal.toLowerSet_injective | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : LE P], Function.Injective Order.Ideal.toLowerSet |
SimpleGraph.cliqueFinset_eq_empty_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : DecidableRel G.Adj] {n : ℕ},
G.cliqueFinset n = ∅ ↔ G.CliqueFree n |
LieAlgebra.IsExtension.range_eq_top | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} (i : N →ₗ⁅R⁆ L) {p : L →ₗ⁅R⁆ M} [self : LieAlgebra.IsExtension i p], p.range = ⊤ |
CategoryTheory.OverPresheafAux.restrictedYoneda._proof_3 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
{X Y : CategoryTheory.Over A} (ε : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ (Type u_2))).map ε.left)
Y.hom =
CategoryTheory.CategoryStruct.comp X.hom ((CategoryTheory.Functor.fromPUnit A).map ε.right) |
Finset.Colex.toColex_sdiff_lt_toColex_sdiff' | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : Finset α} [inst_1 : DecidableEq α],
toColex (s \ t) < toColex (t \ s) ↔ toColex s < toColex t |
Lean.Parser.ParserResolution.alias | Lean.Parser.Extension | Lean.Parser.ParserAliasValue → Lean.Parser.ParserResolution |
HasSubset.noConfusion | Init.Core | {P : Sort u_1} →
{α : Type u} →
{t : HasSubset α} → {α' : Type u} → {t' : HasSubset α'} → α = α' → t ≍ t' → HasSubset.noConfusionType P t t' |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion.match_1 | Lean.Meta.LazyDiscrTree | (motive : Lean.Name → Sort u_1) →
(declName : Lean.Name) → ((pre : Lean.Name) → motive (pre.str "inj")) → ((x : Lean.Name) → motive x) → motive declName |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetValue pu → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Compiler.LCNF.LetValue pu |
CategoryTheory.IsDiscrete.sum | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ (C : Type u_1) (C' : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C'] [CategoryTheory.IsDiscrete C] [CategoryTheory.IsDiscrete C'],
CategoryTheory.IsDiscrete (C ⊕ C') |
USize.toNat_sub_of_le | Init.Data.UInt.Lemmas | ∀ (a b : USize), b ≤ a → (a - b).toNat = a.toNat - b.toNat |
Lean.Compiler.CSimp.replaceConstant | Lean.Compiler.CSimpAttr | Lean.Environment → Lean.Expr → Lean.CoreM Lean.Expr |
_private.Init.Data.Array.BinSearch.0.Array.binSearchAux._proof_3 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin (as.size + 1)) (hi : Fin as.size),
↑lo ≤ ↑hi → ¬(↑lo + ↑hi) / 2 < as.size → False |
PNat.XgcdType.flip_b | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.b = u.a |
Lean.Lsp.LeanIleanInfoParams.recOn | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.LeanIleanInfoParams → Sort u} →
(t : Lean.Lsp.LeanIleanInfoParams) →
((version : ℕ) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) → motive { version := version, references := references, decls := decls }) →
motive t |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.combine_k_eq_combine._simp_1_8 | Init.Grind.Ring.CommSolver | ∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), m₁.grevlex m₂ = m₁.grevlex_k m₂ |
Complex.isOpen_im_lt_EReal | Mathlib.Analysis.Complex.HalfPlane | ∀ (x : EReal), IsOpen {z | ↑z.im < x} |
CategoryTheory.Bundled.mk.noConfusion | Mathlib.CategoryTheory.ConcreteCategory.Bundled | {c : Type u → Type v} →
{P : Sort u_1} →
{α : Type u} →
{str : autoParam (c α) CategoryTheory.Bundled.str._autoParam} →
{α' : Type u} →
{str' : autoParam (c α') CategoryTheory.Bundled.str._autoParam} →
{ α := α, str := str } = { α := α', str := str' } → (α = α' → str ≍ str' → P) → P |
Std.ExtDTreeMap.size_le_size_erase | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, t.size ≤ (t.erase k).size + 1 |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._proof_8 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._auto_1),
⟨k, ⋯⟩ ≤ ⟨k + 1, ⋯⟩ |
riemannZeta.eq_1 | Mathlib.NumberTheory.LSeries.RiemannZeta | riemannZeta = HurwitzZeta.hurwitzZetaEven 0 |
CategoryTheory.ProjectivePresentation.noConfusionType | Mathlib.CategoryTheory.Preadditive.Projective.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
CategoryTheory.ProjectivePresentation X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{X' : C'} → CategoryTheory.ProjectivePresentation X' → Sort u_1 |
HahnSeries.instAddGroup._proof_8 | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddGroup R] (n : ℕ) (x : HahnSeries Γ R),
Int.negSucc n • x = -(↑n.succ • x) |
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.MeasureTheory.measure_of_cont_bdd_of_tendsto_filter_indicator._simp_1_1 | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True |
Filter.comk.congr_simp | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} (p p_1 : Set α → Prop) (e_p : p = p_1) (he : p ∅) (hmono : ∀ (t : Set α), p t → ∀ s ⊆ t, p s)
(hunion : ∀ (s : Set α), p s → ∀ (t : Set α), p t → p (s ∪ t)), Filter.comk p he hmono hunion = Filter.comk p_1 ⋯ ⋯ ⋯ |
CategoryTheory.Pretriangulated.Triangle.epi₃ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles, T.mor₁ = 0 → CategoryTheory.Epi T.mor₃ |
AddSemigroupIdeal.fg_iff | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : Add M] {I : AddSemigroupIdeal M}, I.FG ↔ ∃ s, I = AddSemigroupIdeal.closure ↑s |
Std.ExtTreeMap.isEmpty_eq_size_beq_zero | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp}, t.isEmpty = (t.size == 0) |
NormedAddGroupHom.incl._proof_3 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} [inst : SeminormedAddCommGroup V] (s : AddSubgroup V), ∃ C, ∀ (v : ↥s), ‖↑v‖ ≤ C * ‖v‖ |
Part.Mem | Mathlib.Data.Part | {α : Type u_1} → Part α → α → Prop |
Lean.Server.Watchdog.WorkerEvent.casesOn | Lean.Server.Watchdog | {motive : Lean.Server.Watchdog.WorkerEvent → Sort u} →
(t : Lean.Server.Watchdog.WorkerEvent) →
motive Lean.Server.Watchdog.WorkerEvent.terminated →
motive Lean.Server.Watchdog.WorkerEvent.importsChanged →
((exitCode : UInt32) → motive (Lean.Server.Watchdog.WorkerEvent.crashed exitCode)) →
((e : IO.Error) → motive (Lean.Server.Watchdog.WorkerEvent.ioError e)) → motive t |
Acc.ndrec | Init.WF | {α : Sort u2} →
{r : α → α → Prop} →
{C : α → Sort u1} →
((x : α) → (∀ (y : α), r y x → Acc r y) → ((y : α) → r y x → C y) → C x) → {a : α} → Acc r a → C a |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameM | Lean.Elab.DeclNameGen | Type → Type |
Std.DTreeMap.Const.get!_modify_self | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} {k : α}
[inst : Inhabited β] {f : β → β},
Std.DTreeMap.Const.get! (Std.DTreeMap.Const.modify t k f) k = (Option.map f (Std.DTreeMap.Const.get? t k)).get! |
Prod.instCoheytingAlgebra._proof_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (a : α × β), ⊤ \ a = ￢a |
SSet.StrictSegal.ofIsStrictSegal._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ (X : SSet) [inst : X.IsStrictSegal] (n : ℕ), (Equiv.ofBijective (X.spine n) ⋯).invFun ∘ X.spine n = id |
CoalgHom.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Hom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] →
[inst_3 : AddCommMonoid B] →
[inst_4 : Module R B] →
[inst_5 : CoalgebraStruct R A] →
[inst_6 : CoalgebraStruct R B] →
(toFun : A → B) →
(map_add' : ∀ (x y : A), toFun (x + y) = toFun x + toFun y) →
(map_smul' : ∀ (m : R) (x : A), toFun (m • x) = (RingHom.id R) m • toFun x) →
CoalgebraStruct.counit ∘ₗ { toFun := toFun, map_add' := map_add', map_smul' := map_smul' } =
CoalgebraStruct.counit →
TensorProduct.map { toFun := toFun, map_add' := map_add', map_smul' := map_smul' }
{ toFun := toFun, map_add' := map_add', map_smul' := map_smul' } ∘ₗ
CoalgebraStruct.comul =
CoalgebraStruct.comul ∘ₗ
{ toFun := toFun, map_add' := map_add', map_smul' := map_smul' } →
A →ₗc[R] B |
vectorSpan_mono | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s₁ s₂ : Set P}, s₁ ⊆ s₂ → vectorSpan k s₁ ≤ vectorSpan k s₂ |
BoxIntegral.Prepartition.mk.sizeOf_spec | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} [inst : SizeOf ι] (boxes : Finset (BoxIntegral.Box ι))
(le_of_mem' : ∀ J ∈ boxes, J ≤ I)
(pairwiseDisjoint : (↑boxes).Pairwise (Function.onFun Disjoint BoxIntegral.Box.toSet)),
sizeOf { boxes := boxes, le_of_mem' := le_of_mem', pairwiseDisjoint := pairwiseDisjoint } = 1 + sizeOf boxes |
Lean.Name.str._impl | Init.Prelude | UInt64 → Lean.Name → String → Lean.Name._impl |
conformalAt_id | Mathlib.Analysis.Calculus.Conformal.NormedSpace | ∀ {X : Type u_1} [inst : NormedAddCommGroup X] [inst_1 : NormedSpace ℝ X] (x : X), ConformalAt id x |
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.runPass.match_5 | Mathlib.Tactic.TacticAnalysis | (config : Mathlib.TacticAnalysis.ComplexConfig) →
(motive : Mathlib.TacticAnalysis.TriggerCondition config.ctx → Sort u_1) →
(x : Mathlib.TacticAnalysis.TriggerCondition config.ctx) →
((ctx : config.ctx) → motive (Mathlib.TacticAnalysis.TriggerCondition.accept ctx)) →
((x : Mathlib.TacticAnalysis.TriggerCondition config.ctx) → motive x) → motive x |
DirectSum.GradeZero.semiring._proof_3 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A], (DirectSum.of A 0) 1 = 1 |
Aesop.RuleResult.isSuccessful | Aesop.Search.Expansion | Aesop.RuleResult → Bool |
_private.Mathlib.Data.List.Count.0.List.countP_erase._proof_1_2 | Mathlib.Data.List.Count | ∀ {α : Type u_1} (p : α → Bool) (l : List α), 1 ≤ (List.filter p l).length → 0 < (List.findIdxs p l).length |
MulChar.instMulCharClass | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'],
MulCharClass (MulChar R R') R R' |
Pi.seminormedRing._proof_7 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → SeminormedRing (R i)] (a : (i : ι) → R i), 1 * a = a |
FractionalIdeal.count._proof_2 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDedekindDomain R] (I : FractionalIdeal (nonZeroDivisors R) K),
∃ aI,
Classical.choose ⋯ ≠ 0 ∧
I = FractionalIdeal.spanSingleton (nonZeroDivisors R) ((algebraMap R K) (Classical.choose ⋯))⁻¹ * ↑aI |
Nat.Ico_zero_eq_range | Mathlib.Order.Interval.Finset.Nat | Finset.Ico 0 = Finset.range |
Vector.finIdxOf? | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [BEq α] → Vector α n → α → Option (Fin n) |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.flatten.match_1.splitter | Mathlib.Data.WSeq.Basic | {α : Type u_1} →
(motive : Stream'.WSeq α ⊕ Computation (Stream'.WSeq α) → Sort u_2) →
(x : Stream'.WSeq α ⊕ Computation (Stream'.WSeq α)) →
((s : Stream'.WSeq α) → motive (Sum.inl s)) →
((c' : Computation (Stream'.WSeq α)) → motive (Sum.inr c')) → motive x |
Batteries.RBSet.empty | Batteries.Data.RBMap.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → Batteries.RBSet α cmp |
_private.Mathlib.GroupTheory.MonoidLocalization.Basic.0.Submonoid.LocalizationMap.isCancelMul.match_1_2 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] {S : Submonoid M} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) (n : N) (motive : (∃ x, n * f ↑x.2 = f x.1) → Prop) (x : ∃ x, n * f ↑x.2 = f x.1),
(∀ (ms : M × ↥S) (eq : n * f ↑ms.2 = f ms.1), motive ⋯) → motive x |
CategoryTheory.Limits.HasBinaryProduct | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} → [CategoryTheory.Category.{v, u} C] → C → C → Prop |
Array.isEmpty.eq_1 | Init.Data.Array.DecidableEq | ∀ {α : Type u} (xs : Array α), xs.isEmpty = decide (xs.size = 0) |
Std.instLawfulOrderLeftLeaningMaxOfIsLinearOrderOfLawfulOrderSup | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Max α] [Std.IsLinearOrder α] [Std.LawfulOrderSup α],
Std.LawfulOrderLeftLeaningMax α |
Std.IterM.filter.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [inst_1 : Monad m] (f : β → Bool)
(it : Std.IterM m β), Std.IterM.filter f it = Std.IterM.filterMap (fun b => if f b = true then some b else none) it |
TrivSqZeroExt.snd | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} → {M : Type v} → TrivSqZeroExt R M → M |
AbsoluteValue.eq_trivial_of_isEquiv_trivial | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_1} {S : Type u_2} [inst : Field R] [inst_1 : Semifield S] [inst_2 : LinearOrder S]
[inst_3 : DecidablePred fun x => x = 0] [inst_4 : NoZeroDivisors R] [inst_5 : IsStrictOrderedRing S]
{f : AbsoluteValue R S}, f.IsEquiv AbsoluteValue.trivial ↔ f = AbsoluteValue.trivial |
CauSeq.equiv | Mathlib.Algebra.Order.CauSeq.Basic | {α : Type u_1} →
{β : Type u_2} →
[inst : Field α] →
[inst_1 : LinearOrder α] →
[inst_2 : IsStrictOrderedRing α] →
[inst_3 : Ring β] → {abv : β → α} → [IsAbsoluteValue abv] → Setoid (CauSeq β abv) |
add_lt_add_iff_right_of_ne_top | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommMonoidWithTop α] {a b c : α}, a ≠ ⊤ → (a + b < a + c ↔ b < c) |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_cons_of_ne._proof_1_2 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α} (ha : a ∉ s),
a ≠ b → (Finset.cons a s ha).erase b = Finset.cons a (s.erase b) ⋯ |
IsIntegral.mem_range_algebraMap_of_minpoly_splits | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u_1} {K : Type u_2} {L : Type u_3} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra R K] {x : L} [inst_4 : Algebra R L] [inst_5 : Algebra K L] [IsScalarTower R K L],
IsIntegral R x → (Polynomial.map (algebraMap R K) (minpoly R x)).Splits → x ∈ (algebraMap K L).range |
NoBotOrder.casesOn | Mathlib.Order.Max | {α : Type u_3} →
[inst : LE α] →
{motive : NoBotOrder α → Sort u} →
(t : NoBotOrder α) → ((exists_not_ge : ∀ (a : α), ∃ b, ¬a ≤ b) → motive ⋯) → motive t |
TendstoLocallyUniformlyOn.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3} {X : Type u_4}
[inst_3 : TopologicalSpace X] {F G : ι → X → α} {f g : X → α} {s : Set X} {l : Filter ι},
TendstoLocallyUniformlyOn F f l s →
TendstoLocallyUniformlyOn G g l s →
TendstoLocallyUniformlyOn (fun i i_1 => F i i_1 - G i i_1) (fun i => f i - g i) l s |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.injOn_setOf_mem_Icc_setOf_lower_eq._simp_1_2 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a |
_private.Init.Data.Int.Gcd.0.Int.gcd_eq_natAbs_right_iff_dvd._simp_1_1 | Init.Data.Int.Gcd | ∀ {n m : ℕ}, (n.gcd m = m) = (m ∣ n) |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff'._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {A : E →L[𝕜] E}, IsSelfAdjoint A = (↑A).IsSymmetric |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.parallelPair.match_1.eq_2 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ (motive : CategoryTheory.Limits.WalkingParallelPair → Sort u_1)
(h_1 : Unit → motive CategoryTheory.Limits.WalkingParallelPair.zero)
(h_2 : Unit → motive CategoryTheory.Limits.WalkingParallelPair.one),
(match CategoryTheory.Limits.WalkingParallelPair.one with
| CategoryTheory.Limits.WalkingParallelPair.zero => h_1 ()
| CategoryTheory.Limits.WalkingParallelPair.one => h_2 ()) =
h_2 () |
IsRealClosed.rec | Mathlib.FieldTheory.IsRealClosed.Basic | {R : Type u_1} →
[inst : Field R] →
{motive : IsRealClosed R → Sort u} →
([toIsSemireal : IsSemireal R] →
(isSquare_or_isSquare_neg : ∀ (x : R), IsSquare x ∨ IsSquare (-x)) →
(exists_isRoot_of_odd_natDegree : ∀ {f : Polynomial R}, Odd f.natDegree → ∃ x, f.IsRoot x) → motive ⋯) →
(t : IsRealClosed R) → motive t |
Lean.Lsp.FoldingRangeKind.ctorElim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.FoldingRangeKind → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Lsp.FoldingRangeKind) → ctorIdx = t.ctorIdx → Lean.Lsp.FoldingRangeKind.ctorElimType ctorIdx → motive t |
Char.reduceIsUpper._regBuiltin.Char.reduceIsUpper.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.2972409855._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit |
Ordnode.Bounded._sparseCasesOn_1.else_eq | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Ordnode.Bounded._sparseCasesOn_1 t some «else» = «else» h |
Std.Internal.List.Const.getValue_alterKey_self._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} [inst : BEq α] {β : Type u_1} [EquivBEq α] (k : α) (f : Option β → Option β) (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k (Std.Internal.List.Const.alterKey k f l) = true →
(f (Std.Internal.List.getValue? k l)).isSome = true |
_private.Init.Data.Array.Basic.0.Array.allDiffAux._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α), ∀ i < as.size, InvImage (fun x1 x2 => x1 < x2) (fun x => as.size - x) (i + 1) i |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.Rxo.LawfulHasSize.of_closed._simp_6 | Init.Data.Range.Polymorphic.Instances | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, (0 < Std.Rxc.HasSize.size lo hi) = (lo ≤ hi) |
CoxeterSystem.exists_reduced_word | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (w : W),
∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω |
Submodule.spanRank_toENat_eq_iInf_finset_card | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.toENat p.spanRank = ⨅ s, ↑(↑s).card |
ProofWidgets.Component.mk.sizeOf_spec | ProofWidgets.Component.Basic | ∀ {Props : Type} [inst : SizeOf Props] (toModule : Lean.Widget.Module) («export» : String),
sizeOf { toModule := toModule, «export» := «export» } = 1 + sizeOf toModule + sizeOf «export» |
Int64.ofNat_add | Init.Data.SInt.Lemmas | ∀ (a b : ℕ), Int64.ofNat (a + b) = Int64.ofNat a + Int64.ofNat b |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.artanh_neg._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x : ℝ}, x ∈ Set.Ioo (-1) 0 → x ∈ Set.Ioo (-1) 1 |
IsSolvable | Mathlib.GroupTheory.Solvable | (G : Type u_1) → [Group G] → Prop |
AddSubgroup.relIndex_eq_two_iff | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G},
H.relIndex K = 2 ↔ ∃ a ∈ K, ∀ b ∈ K, Xor' (b + a ∈ H) (b ∈ H) |
ZMod.valMinAbs_natCast_eq_self._simp_1 | Mathlib.Data.ZMod.ValMinAbs | ∀ {n a : ℕ} [NeZero n], ((↑a).valMinAbs = ↑a) = (a ≤ n / 2) |
OpenSubgroup.instPartialOrder.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
OpenSubgroup.instPartialOrder = PartialOrder.ofSetLike (OpenSubgroup G) G |
AddOpposite.instNonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (a b c : Rᵃᵒᵖ), (a + b) * c = a * c + b * c |
ModuleCon.instAddCommMagmaQuotient | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
(M : Type u_3) →
[inst : SMul S M] → [inst_1 : AddCommMagma M] → (c : ModuleCon S M) → AddCommMagma (ModuleCon.Quotient M c) |
List.diff.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(x x_1 : List α) →
((l : List α) → motive l []) → ((l₁ : List α) → (a : α) → (l₂ : List α) → motive l₁ (a :: l₂)) → motive x x_1 |
UniformSpace.replaceTopology_eq | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_2} [i : TopologicalSpace α] (u : UniformSpace α) (h : i = u.toTopologicalSpace), u.replaceTopology h = u |
Equiv.Perm.cycleOf_apply_apply_self | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} (f : Equiv.Perm α) [inst : DecidableRel f.SameCycle] (x : α), (f.cycleOf x) (f x) = f (f x) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.