name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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 | {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) |
instContinuousMulULift | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M], ContinuousMul (ULift.{u, u_3} M) |
WithZero.mapAddHom_injective | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Add α] [inst_1 : Add β] {f : α →ₙ+ β},
Function.Injective ⇑f → Function.Injective ⇑(WithZero.mapAddHom f) |
_private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.zeckendorf_sum_fib._simp_1_15 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : LE α] [CanonicallyOrderedAdd α] (a : α), (0 ≤ a) = True |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionActionOfMonoidalFunctorToEndofunctorMopIso | Mathlib.CategoryTheory.Monoidal.Action.End | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) →
[inst_3 : F.Monoidal] → CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionMop C D ≅ F |
NormedRing.inverse_add_norm | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R] (x : Rˣ),
(fun t => Ring.inverse (↑x + t)) =O[nhds 0] fun _t => 1 |
nonempty_subtype | Mathlib.Logic.Nonempty | ∀ {α : Sort u_3} {p : α → Prop}, Nonempty (Subtype p) ↔ ∃ a, p a |
CategoryTheory.Over.pullback.congr_simp | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f f_1 : X ⟶ Y) (e_f : f = f_1)
[inst_1 : CategoryTheory.Limits.HasPullbacksAlong f],
CategoryTheory.Over.pullback f = CategoryTheory.Over.pullback f_1 |
SSet.stdSimplex.instFunLikeObjOppositeSimplexCategoryMkOpFinHAddNatOfNat | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | (n i : ℕ) →
FunLike ((SSet.stdSimplex.obj (SimplexCategory.mk n)).obj (Opposite.op (SimplexCategory.mk i))) (Fin (i + 1))
(Fin (n + 1)) |
NumberField.nrRealPlaces_eq_zero_iff | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {K : Type u_2} [inst : Field K] [inst_1 : NumberField K],
NumberField.InfinitePlace.nrRealPlaces K = 0 ↔ NumberField.IsTotallyComplex K |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go.eq_2 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (x x_1 : List α),
(x = [] → False) → List.MergeSort.Internal.mergeTR.go✝ le x [] x_1 = x_1.reverseAux x |
HasCompactMulSupport.comp_homeomorph | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_9} {Y : Type u_10} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {M : Type u_11}
[inst_2 : One M] {f : Y → M}, HasCompactMulSupport f → ∀ (φ : X ≃ₜ Y), HasCompactMulSupport (f ∘ ⇑φ) |
CategoryTheory.Limits.MultispanShape._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ |
differentiableOn_intCast | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {s : Set E} [inst_7 : IntCast F] (z : ℤ), DifferentiableOn 𝕜 (↑z) s |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.ctorElim | Std.Tactic.BVDecide.LRAT.Internal.Assignment | {motive : Std.Tactic.BVDecide.LRAT.Internal.Assignment → Sort u} →
(ctorIdx : ℕ) →
(t : Std.Tactic.BVDecide.LRAT.Internal.Assignment) →
ctorIdx = t.ctorIdx → Std.Tactic.BVDecide.LRAT.Internal.Assignment.ctorElimType ctorIdx → motive t |
String.valid_toSubstring | Batteries.Data.String.Lemmas | ∀ (s : String), s.toRawSubstring.Valid |
OrderIso.setIsotypicComponents_apply | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsSemisimpleModule R M] (s : Set ↑(isotypicComponents R M)),
OrderIso.setIsotypicComponents s = ⨆ c ∈ s, ⟨↑c, ⋯⟩ |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.addAuxRecs.match_1 | Lean.Elab.MutualInductive | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((const : Lean.ConstantInfo) → motive (some const)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x |
PSigma.Lex.recOn | Init.WF | ∀ {α : Sort u} {β : α → Sort v} {r : α → α → Prop} {s : (a : α) → β a → β a → Prop}
{motive : (a a_1 : PSigma β) → PSigma.Lex r s a a_1 → Prop} {a a_1 : PSigma β} (t : PSigma.Lex r s a a_1),
(∀ {a₁ : α} (b₁ : β a₁) {a₂ : α} (b₂ : β a₂) (a : r a₁ a₂), motive ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⋯) →
(∀ (a : α) {b₁ b₂ : β a} (a_2 : s a b₁ b₂), motive ⟨a, b₁⟩ ⟨a, b₂⟩ ⋯) → motive a a_1 t |
finsum_eq_if | Mathlib.Algebra.BigOperators.Finprod | ∀ {M : Type u_2} [inst : AddCommMonoid M] {p : Prop} [inst_1 : Decidable p] {x : M}, ∑ᶠ (_ : p), x = if p then x else 0 |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqPoly.beq.match_1.splitter | Init.Grind.Ring.CommSolver | (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) →
(x x_1 : Lean.Grind.CommRing.Poly) →
((a b : ℤ) → motive (Lean.Grind.CommRing.Poly.num a) (Lean.Grind.CommRing.Poly.num b)) →
((a : ℤ) →
(a_1 : Lean.Grind.CommRing.Mon) →
(a_2 : Lean.Grind.CommRing.Poly) →
(b : ℤ) →
(b_1 : Lean.Grind.CommRing.Mon) →
(b_2 : Lean.Grind.CommRing.Poly) →
motive (Lean.Grind.CommRing.Poly.add a a_1 a_2) (Lean.Grind.CommRing.Poly.add b b_1 b_2)) →
((x x_2 : Lean.Grind.CommRing.Poly) →
(∀ (a b : ℤ), x = Lean.Grind.CommRing.Poly.num a → x_2 = Lean.Grind.CommRing.Poly.num b → False) →
(∀ (a : ℤ) (a_1 : Lean.Grind.CommRing.Mon) (a_2 : Lean.Grind.CommRing.Poly) (b : ℤ)
(b_1 : Lean.Grind.CommRing.Mon) (b_2 : Lean.Grind.CommRing.Poly),
x = Lean.Grind.CommRing.Poly.add a a_1 a_2 → x_2 = Lean.Grind.CommRing.Poly.add b b_1 b_2 → False) →
motive x x_2) →
motive x x_1 |
_private.Lean.Meta.Tactic.Grind.Attr.0.Lean.Meta.Grind.Extension.addFunCCAttr | Lean.Meta.Tactic.Grind.Attr | Lean.Meta.Grind.Extension → Lean.Name → Lean.AttributeKind → Lean.CoreM Unit |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.