name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
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 | true |
Lean.Name.str._impl | Init.Prelude | UInt64 → Lean.Name → String → Lean.Name._impl | false |
conformalAt_id | Mathlib.Analysis.Calculus.Conformal.NormedSpace | ∀ {X : Type u_1} [inst : NormedAddCommGroup X] [inst_1 : NormedSpace ℝ X] (x : X), ConformalAt id x | true |
_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 | false |
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 | false |
Aesop.RuleResult.isSuccessful | Aesop.Search.Expansion | Aesop.RuleResult → Bool | true |
_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 | false |
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' | true |
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 | false |
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 | false |
Nat.Ico_zero_eq_range | Mathlib.Order.Interval.Finset.Nat | Finset.Ico 0 = Finset.range | true |
Vector.finIdxOf? | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [BEq α] → Vector α n → α → Option (Fin n) | true |
_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 | true |
Batteries.RBSet.empty | Batteries.Data.RBMap.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → Batteries.RBSet α cmp | true |
_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 | false |
CategoryTheory.Limits.HasBinaryProduct | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} → [CategoryTheory.Category.{v, u} C] → C → C → Prop | true |
Array.isEmpty.eq_1 | Init.Data.Array.DecidableEq | ∀ {α : Type u} (xs : Array α), xs.isEmpty = decide (xs.size = 0) | true |
Std.instLawfulOrderLeftLeaningMaxOfIsLinearOrderOfLawfulOrderSup | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Max α] [Std.IsLinearOrder α] [Std.LawfulOrderSup α],
Std.LawfulOrderLeftLeaningMax α | true |
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 | true |
TrivSqZeroExt.snd | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} → {M : Type v} → TrivSqZeroExt R M → M | true |
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) | true |
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) | true |
_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) ⋯ | false |
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 | true |
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 | false |
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 | true |
_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 | false |
_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) | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_451 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
_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 | false |
_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 () | true |
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 | false |
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 | false |
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 | false |
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 | false |
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 | false |
_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 | false |
_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) | false |
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 ω | true |
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 | true |
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» | true |
Int64.ofNat_add | Init.Data.SInt.Lemmas | ∀ (a b : ℕ), Int64.ofNat (a + b) = Int64.ofNat a + Int64.ofNat b | true |
_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 | false |
IsSolvable | Mathlib.GroupTheory.Solvable | (G : Type u_1) → [Group G] → Prop | true |
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) | true |
ZMod.valMinAbs_natCast_eq_self._simp_1 | Mathlib.Data.ZMod.ValMinAbs | ∀ {n a : ℕ} [NeZero n], ((↑a).valMinAbs = ↑a) = (a ≤ n / 2) | false |
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 | true |
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 | false |
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) | true |
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 | false |
UniformSpace.replaceTopology_eq | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_2} [i : TopologicalSpace α] (u : UniformSpace α) (h : i = u.toTopologicalSpace), u.replaceTopology h = u | true |
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) | true |
instContinuousMulULift | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M], ContinuousMul (ULift.{u, u_3} M) | true |
SetLike.GradeZero.instMonoid._aux_4 | Mathlib.Algebra.GradedMonoid | {ι : Type u_3} →
{R : Type u_1} →
{S : Type u_2} →
[inst : SetLike S R] →
[inst_1 : Monoid R] → [inst_2 : AddMonoid ι] → {A : ι → S} → [SetLike.GradedMonoid A] → ↥(A 0) | false |
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) | true |
_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 | false |
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 | true |
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 | true |
nonempty_subtype | Mathlib.Logic.Nonempty | ∀ {α : Sort u_3} {p : α → Prop}, Nonempty (Subtype p) ↔ ∃ a, p a | true |
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 | true |
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)) | true |
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 | true |
_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 | true |
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 ∘ ⇑φ) | true |
CategoryTheory.Limits.MultispanShape._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ | false |
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 | true |
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 | false |
String.valid_toSubstring | Batteries.Data.String.Lemmas | ∀ (s : String), s.toRawSubstring.Valid | true |
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, ⋯⟩ | true |
_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 | false |
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 | false |
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 | true |
_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 | true |
_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 | true |
Nat.recDiagAux_succ_succ | Batteries.Data.Nat.Lemmas | ∀ {motive : ℕ → ℕ → Sort u_1} (zero_left : (n : ℕ) → motive 0 n) (zero_right : (m : ℕ) → motive m 0)
(succ_succ : (m n : ℕ) → motive m n → motive (m + 1) (n + 1)) (m n : ℕ),
Nat.recDiagAux zero_left zero_right succ_succ (m + 1) (n + 1) =
succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n) | true |
CategoryTheory.Equivalence.changeFunctor._proof_2 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D) {G : CategoryTheory.Functor C D} (iso : e.functor ≅ G)
(X : C),
CategoryTheory.CategoryStruct.comp
(G.map ((e.unitIso ≪≫ CategoryTheory.Functor.isoWhiskerRight iso e.inverse).hom.app X))
((e.inverse.isoWhiskerLeft iso.symm ≪≫ e.counitIso).hom.app (G.obj X)) =
CategoryTheory.CategoryStruct.id (G.obj X) | false |
CategoryTheory.PreZeroHypercover.hom_inv_h₀._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S}
(e : E ≅ F) (i : E.I₀), E.X i = E.X (e.inv.s₀ (e.hom.s₀ i)) | false |
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_11 | Mathlib.RingTheory.LittleWedderburn | ∀ {D : Type u_1} [inst : DivisionRing D] {R : Subring D} [inst_1 : Fintype D] [inst_2 : DecidableEq D]
[inst_3 : DecidablePred fun x => x ∈ R] (q : ℚ≥0) (a : ↥R), DivisionRing.nnqsmul q a = ↑q * a | false |
_private.Mathlib.Topology.QuasiSeparated.0.QuasiSeparatedSpace.isCompact_sInter_of_nonempty._proof_1_8 | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set (Set α)},
(∀ t ∈ s, IsCompact t) → ∀ t_1 ∈ {t | t ∈ s ∧ IsOpen t}, IsCompact t_1 | false |
_private.Mathlib.CategoryTheory.Limits.Opposites.0.CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ι._simp_1_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) | false |
Lean.Elab.Command.Structure.checkValidFieldModifier | Lean.Elab.Structure | Lean.Elab.Modifiers → Lean.Elab.TermElabM Unit | true |
LipschitzWith.compLp | Mathlib.MeasureTheory.Function.LpSpace.Basic | {α : Type u_1} →
{E : Type u_4} →
{F : Type u_5} →
{m : MeasurableSpace α} →
{p : ENNReal} →
{μ : MeasureTheory.Measure α} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
{g : E → F} →
{c : NNReal} → LipschitzWith c g → g 0 = 0 → ↥(MeasureTheory.Lp E p μ) → ↥(MeasureTheory.Lp F p μ) | true |
FormalMultilinearSeries.leftInv._proof_30 | Mathlib.Analysis.Analytic.Inverse | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F | false |
_private.Init.Data.Array.Lemmas.0.Array.range.eq_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), Array.range n = Array.ofFn fun i => ↑i | true |
List.merge_of_le | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} {xs ys : List α},
(∀ (a b : α), a ∈ xs → b ∈ ys → le a b = true) → xs.merge ys le = xs ++ ys | true |
Std.TreeMap.Raw.Equiv.getEntryLT?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α},
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLT? k = t₂.getEntryLT? k | true |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map₂_comp | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
self.map₂ (CategoryTheory.CategoryStruct.comp η θ) = CategoryTheory.CategoryStruct.comp (self.map₂ η) (self.map₂ θ) | true |
Lean.Parser.Tactic.quot | Lean.Parser.Term | Lean.Parser.Parser | true |
ArchimedeanClass.FiniteResidueField.instField._proof_1 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K]
(a b c : ArchimedeanClass.FiniteResidueField K), a + b + c = a + (b + c) | false |
ContinuousMultilinearMap.currySumEquiv._proof_10 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace 𝕜 G'], ContinuousConstSMul 𝕜 G' | false |
Std.TreeSet.Raw.toList_roc | Std.Data.TreeSet.Raw.Slice | ∀ {α : Type u} (cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.toList_roc._auto_1) [Std.TransCmp cmp]
{t : Std.TreeSet.Raw α cmp},
t.WF →
∀ {lowerBound upperBound : α},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice t lowerBound<...=upperBound) =
List.filter (fun e => decide ((cmp e lowerBound).isGT = true ∧ (cmp e upperBound).isLE = true)) t.toList | true |
contMDiffOn_zero_iff | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {s : Set M},
ContMDiffOn I I' 0 f s ↔ ContinuousOn f s | true |
LibraryNote.foundational_algebra_order_theory | Mathlib.Data.Nat.Init | Batteries.Util.LibraryNote | true |
Fintype | Mathlib.Data.Fintype.Defs | Type u_4 → Type u_4 | true |
Subalgebra.val._proof_5 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (x : R), ↑((algebraMap R ↥S) x) = ↑((algebraMap R ↥S) x) | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.isType2Type._sparseCasesOn_2 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
Rat.instNormedField | Mathlib.Analysis.Normed.Field.Lemmas | NormedField ℚ | true |
SimplexCategory.toTopHomeo_symm_naturality_apply | Mathlib.AlgebraicTopology.SimplicialSet.TopAdj | ∀ {n m : SimplexCategory} (f : n ⟶ m) (x : ↑(stdSimplex ℝ (Fin (n.len + 1)))),
m.toTopHomeo.symm (stdSimplex.map (⇑(CategoryTheory.ConcreteCategory.hom f)) x) =
(CategoryTheory.ConcreteCategory.hom (SSet.toTop.map (SSet.stdSimplex.map f))) (n.toTopHomeo.symm x) | true |
sqrt_one_add_norm_sq_le | Mathlib.Analysis.SpecialFunctions.JapaneseBracket | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (x : E), √(1 + ‖x‖ ^ 2) ≤ 1 + ‖x‖ | true |
instAddUInt32 | Init.Data.UInt.BasicAux | Add UInt32 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.