name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Function.FromTypes.curry_apply_succ | Mathlib.Data.Fin.Tuple.Curry | ∀ {n : ℕ} {p : Fin (n + 1) → Type u} {τ : Type u} (f : ((i : Fin (n + 1)) → p i) → τ) (a : p 0),
Function.FromTypes.curry f a = Function.FromTypes.curry (f ∘ Fin.cons a) | true |
Char.beqCaseInsensitiveAsciiOnly | Batteries.Data.Char.AsciiCasing | Char → Char → Bool | true |
_private.Mathlib.FieldTheory.AxGrothendieck.0.FirstOrder.realize_genericPolyMapSurjOnOfInjOn._simp_1_8 | Mathlib.FieldTheory.AxGrothendieck | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
(t₁ t₂ : L.Term (α ⊕ Fin l)),
(t₁.bdEqual t₂).Realize v xs =
(FirstOrder.Language.Term.realize (Sum.elim v xs) t₁ = FirstOrder.Language.Term.realize (Sum.elim v xs) t₂) | false |
AddSubgroup.vadd_mem_of_mem_closure_of_mem | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] {X : Type u_5} [inst_1 : AddAction G X] {s : Set G} {t : Set X},
(∀ g ∈ s, -g ∈ s) →
(∀ g ∈ s, ∀ x ∈ t, g +ᵥ x ∈ t) → ∀ {g : G}, g ∈ AddSubgroup.closure s → ∀ {x : X}, x ∈ t → g +ᵥ x ∈ t | true |
AddCommGrpCat.coyoneda._proof_1 | Mathlib.Algebra.Category.Grp.Yoneda | ∀ (M : AddCommGrpCatᵒᵖ) (X : AddCommGrpCat),
AddCommGrpCat.ofHom (AddMonoidHom.compHom (AddCommGrpCat.Hom.hom (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.CategoryStruct.id (AddCommGrpCat.of (↑(Opposite.unop M) →+ ↑X)) | false |
Std.ExtDTreeMap.maxKey?_eq_none_iff._simp_1 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp],
(t.maxKey? = none) = (t = ∅) | false |
IsLocallyClosed.inter | Mathlib.Topology.LocallyClosed | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X},
IsLocallyClosed s → IsLocallyClosed t → IsLocallyClosed (s ∩ t) | true |
Polynomial.chebyshev_T_eq_dickson_one_one | Mathlib.RingTheory.Polynomial.Dickson | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : Invertible 2] (n : ℕ),
Polynomial.Chebyshev.T R ↑n = Polynomial.C ⅟2 * (Polynomial.dickson 1 1 n).comp (2 * Polynomial.X) | true |
FundamentalGroupoidFunctor.instIsIsoFunctorFundamentalGroupoidHomotopicMapsNatIso | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f g : C(X, Y)}
(H : f.Homotopy g), CategoryTheory.IsIso (FundamentalGroupoidFunctor.homotopicMapsNatIso H) | true |
CategoryTheory.Arrow.hom_inv_id_left | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (e : f ≅ g),
CategoryTheory.CategoryStruct.comp e.hom.left e.inv.left = CategoryTheory.CategoryStruct.id f.left | true |
IsLocalDiffeomorph.isOpen_range | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_4}
[inst_5 : TopologicalSpace H] {G : Type u_5} [inst_6 : TopologicalSpace G] {I : ModelWithCorners ... | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.0.Equiv.Perm.closure_cycleType_eq_two_two_eq_alternatingGroup._proof_1_6 | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst_1 : DecidableEq α] ⦃g : Equiv.Perm α⦄ (a b c w : α),
2 ≤ List.count w [a, g a, b, c] → 1 < (List.filter (fun x => decide (x = w)) [a, g a, b, c]).length | false |
rank_submodule_eq_one_iff | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {K : Type u} {V : Type v} [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
(s : Submodule K V) [Module.Free K ↥s], Module.rank K ↥s = 1 ↔ ∃ v₀ ∈ s, v₀ ≠ 0 ∧ s ≤ K ∙ v₀ | true |
Matrix.sum_apply | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_11} {β : Type u_12} [inst : AddCommMonoid α] (i : m) (j : n) (s : Finset β)
(g : β → Matrix m n α), (∑ c ∈ s, g c) i j = ∑ c ∈ s, g c i j | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.terminalReplacement._sparseCasesOn_1 | Mathlib.Tactic.TacticAnalysis.Declarations | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
IO.Process.SpawnArgs.mk._flat_ctor | Init.System.IO | IO.Process.Stdio →
IO.Process.Stdio →
IO.Process.Stdio →
String →
Array String → Option System.FilePath → Array (String × Option String) → Bool → Bool → IO.Process.SpawnArgs | false |
CategoryTheory.MonadIso.mk | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{M N : CategoryTheory.Monad C} →
(f : M.toFunctor ≅ N.toFunctor) →
autoParam (∀ (X : C), CategoryTheory.CategoryStruct.comp (M.η.app X) (f.hom.app X) = N.η.app X)
CategoryTheory.MonadIso.mk._auto_1 →
autoParam
... | true |
USize.zero_add | Init.Data.UInt.Lemmas | ∀ (a : USize), 0 + a = a | true |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitDecl.match_1 | Lean.Compiler.IR.EmitLLVM | (motive : DoResultPR Unit Unit PUnit.{1} → Sort u_1) →
(r : DoResultPR Unit Unit PUnit.{1}) →
((a : Unit) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Unit) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | false |
List.mem_ofFn._simp_1 | Init.Data.List.OfFn | ∀ {α : Type u_1} {n : ℕ} {f : Fin n → α} {a : α}, (a ∈ List.ofFn f) = ∃ i, f i = a | false |
HasProdUniformly.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] (f : ι → β → α) (g : β → α)
[inst_1 : UniformSpace α], HasProdUniformly f g = HasProd (⇑UniformFun.ofFun ∘ f) (UniformFun.ofFun g) | true |
ProjectiveSpectrum.basicOpen_mul_le_left | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f g : A), ProjectiveSpectrum.basicOpen 𝒜 (f * g) ≤ ProjectiveSpectrum.basicOpen 𝒜 f | true |
CategoryTheory.PreZeroHypercover.Relation.snd | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S : C} → {E : CategoryTheory.PreZeroHypercover S} → {i j : E.I₀} → (self : E.Relation i j) → self.obj ⟶ E.X j | true |
HasOuterApproxClosed.indicator_le_apprSeq | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : HasOuterApproxClosed X] {F : Set X} (hF : IsClosed F) (n : ℕ),
(F.indicator fun x => 1) ≤ ⇑(hF.apprSeq n) | true |
Fin.dfoldrM.loop.match_1 | Batteries.Data.Fin.Basic | (n : ℕ) →
(α : Fin (n + 1) → Type u_2) →
(motive : (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → Sort u_1) →
(i : ℕ) →
(h : i < n + 1) →
(x : α ⟨i, h⟩) →
((i : ℕ) → (h : i + 1 < n + 1) → (x : α ⟨i + 1, h⟩) → motive i.succ h x) →
((h : 0 < n + 1) → (x : α ⟨0, h⟩) → motive... | false |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.CastKind._sizeOf_inst | Mathlib.Tactic.Translate.TagUnfoldBoundary | SizeOf Mathlib.Tactic.Translate.CastKind✝ | false |
CoalgEquivClass.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {F : Type u_5} {R : outParam (Type u_6)} {A : outParam (Type u_7)} {B : outParam (Type u_8)} [inst : CommSemiring R]
[inst_1 : AddCommMonoid A] [inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B]
[inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B] [inst_7 : EquivLike F A B]
(map_add... | false |
CategoryTheory.Limits.ι_colimitLimitIso_limit_π_assoc | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
[inst_4 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_5 : CategoryTheory.Li... | true |
Polynomial.separable_X_add_C | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] (a : R), (Polynomial.X + Polynomial.C a).Separable | true |
MeasureTheory.IntegrableOn.comp_neg_Ici | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_4} {F : Type u_6} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.Measure G}
[inst_2 : PartialOrder G] [inst_3 : AddCommGroup G] [IsOrderedAddMonoid G] [MeasurableNeg G] [μ.IsNegInvariant]
{c : G} {f : G → F},
MeasureTheory.IntegrableOn f (Set.Iic (-c)) μ → MeasureTheor... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget aig len → Sort u} →
({w : ℕ} → (vec : aig.RefVec w) → (start : ℕ) → motive { w := w, vec := vec, start := start }) →
... | false |
Std.ExtDTreeMap.Const.unitOfList | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
List α →
(cmp : autoParam (α → α → Ordering) Std.ExtDTreeMap.Const.unitOfList._auto_1) →
Std.ExtDTreeMap α (fun x => Unit) cmp | true |
CommBialgCat.Hom.casesOn | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
{A B : CommBialgCat R} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →ₐc[R] ↑B) → motive { hom' := hom' }) → motive t | false |
IntermediateField.map_mem_map | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (S : IntermediateField K L) (f : L →ₐ[K] L') {x : L},
f x ∈ IntermediateField.map f S ↔ x ∈ S | true |
CategoryTheory.GrothendieckTopology.noConfusionType | Mathlib.CategoryTheory.Sites.Grothendieck | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.GrothendieckTopology C →
{C' : Type u} → [inst' : CategoryTheory.Category.{v, u} C'] → CategoryTheory.GrothendieckTopology C' → Sort u_1 | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabForallParamsWithSignature.delabParams._unsafe_rec | Lean.PrettyPrinter.Delaborator.Builtins | {α : Type} →
(Lean.TSyntaxArray `Lean.Parser.Term.bracketedBinder → Lean.Term → Lean.PrettyPrinter.Delaborator.DelabM α) →
Lean.NameSet → Lean.TSyntaxArray `Lean.Parser.Term.bracketedBinder → Lean.PrettyPrinter.Delaborator.DelabM α | false |
_private.Mathlib.MeasureTheory.Group.Measure.0.MeasureTheory.forall_measure_preimage_mul_right_iff._simp_1_1 | Mathlib.MeasureTheory.Group.Measure | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ₁ μ₂ : MeasureTheory.Measure α},
(μ₁ = μ₂) = ∀ (s : Set α), MeasurableSet s → μ₁ s = μ₂ s | false |
CategoryTheory.Quotient.equiv._proof_1 | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C),
Function.LeftInverse (fun x => { as := x }) fun x => x.as | false |
Finset.lcm | Mathlib.Algebra.GCDMonoid.Finset | {α : Type u_2} → {β : Type u_3} → [inst : CommMonoidWithZero α] → [NormalizedGCDMonoid α] → Finset β → (β → α) → α | true |
Set.div_sInter_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} [inst : Div α] (s : Set α) (T : Set (Set α)), s / ⋂₀ T ⊆ ⋂ t ∈ T, s / t | true |
CategoryTheory.WithInitial.instCategory._proof_6 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : CategoryTheory.WithInitial C} (f : W.Hom X)
(g : X.Hom Y) (h : Y.Hom Z),
CategoryTheory.WithInitial.comp (CategoryTheory.WithInitial.comp f g) h =
CategoryTheory.WithInitial.comp f (CategoryTheory.WithInitial.comp g h) | false |
Antitone.map_max | Mathlib.Order.MinMax | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β} {a b : α},
Antitone f → f (max a b) = min (f a) (f b) | true |
SubAddAction.vadd' | Mathlib.GroupTheory.GroupAction.SubMulAction | {S : Type u'} →
{R : Type u} →
{M : Type v} →
[inst : AddMonoid R] →
[inst_1 : AddAction R M] →
[inst_2 : VAdd S R] → [inst_3 : VAdd S M] → [VAddAssocClass S R M] → (p : SubAddAction R M) → VAdd S ↥p | true |
CategoryTheory.Functor.map_shiftFunctorCompIsoId_inv_app | Mathlib.CategoryTheory.Shift.CommShift | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : F.CommShift A] (X : C)
(a b :... | true |
InnerProductGeometry.angle_smul_left_of_pos | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V) {r : ℝ},
0 < r → InnerProductGeometry.angle (r • x) y = InnerProductGeometry.angle x y | true |
RelIso.injective | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (e : r ≃r s), Function.Injective ⇑e | true |
_private.Lean.Elab.Macro.0.Lean.Elab.Command.elabMacro.match_10 | Lean.Elab.Macro | (motive : Array (Lean.TSyntax `stx) × Array Lean.Term → Sort u_1) →
(x : Array (Lean.TSyntax `stx) × Array Lean.Term) →
((stxParts : Array (Lean.TSyntax `stx)) → (patArgs : Array Lean.Term) → motive (stxParts, patArgs)) → motive x | false |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.Rxc.instIsAlwaysFiniteOfLawfulHasSize._simp_1 | Init.Data.Range.Polymorphic.Instances | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, (Std.Rxc.HasSize.size lo hi = 0) = ¬lo ≤ hi | false |
Std.Internal.List.getValue?_list_unit | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] {l : List ((_ : α) × Unit)} {k : α},
Std.Internal.List.getValue? k l = if Std.Internal.List.containsKey k l = true then some () else none | true |
Lean.instHashableBinderInfo | Lean.Expr | Hashable Lean.BinderInfo | true |
IsNonarchimedeanLocalField.isCompact_closedBall | Mathlib.NumberTheory.LocalField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : TopologicalSpace K] [IsNonarchimedeanLocalField K]
(γ : ValuativeRel.ValueGroupWithZero K), IsCompact {x | (ValuativeRel.valuation K) x ≤ γ} | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.Tendsto.const_mul._simp_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {X : Type u} [inst : TopologicalSpace X] {α : Type u_1} {x : X} {f : Filter α},
Filter.Tendsto (fun x_1 => x) f (nhds x) = True | false |
MvPFunctor.wPathDestRight_wPathCasesOn | Mathlib.Data.PFunctor.Multivariate.W | ∀ {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u_1} n} {a : P.A} {f : P.last.B a → P.last.W}
(g' : (P.drop.B a).Arrow α) (g : (j : P.last.B a) → TypeVec.Arrow (P.WPath (f j)) α),
P.wPathDestRight (P.wPathCasesOn g' g) = g | true |
_private.Mathlib.Analysis.RCLike.Basic.0.RCLike.re_eq_ofReal_of_isSelfAdjoint._simp_1_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {x : K}, (RCLike.im x = 0) = IsSelfAdjoint x | false |
SchwartzMap.smulLeftCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | {𝕜 : Type u_2} →
{E : Type u_5} →
(F : Type u_6) →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
[inst_4 : NontriviallyNormedField 𝕜] →
[inst_5 : NormedAlgebra ℝ 𝕜] →
... | true |
Coalgebra.Repr.arbitrary._proof_1 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (a : A), ∃ S, CoalgebraStruct.comul a = ∑ i ∈ S, i.1 ⊗ₜ[R] i.2 | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate._sizeOf_1 | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitCandidate✝ → ℕ | false |
hasGradientAtFilter_iff_isLittleO | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {f' x : F} {L : Filter F},
HasGradientAtFilter f f' x L ↔ (fun x' => f x' - f x - inner 𝕜 f' (x' - x)) =o[L] fun x' => x' - x | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_203 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w [g (g a)] 1 + 1 ≤ (List.filter (fun x => decide (x = w_1)) []).length →
List.idxOfNth w [g (g a)] 1 < (List.findIdxs (fun x => decide (x = w_1)) []).length | false |
Fin.addNat_inj._simp_1 | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (m : ℕ) {i j : Fin n}, (i.addNat m = j.addNat m) = (i = j) | false |
Subalgebra.equivOfEq._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
AddSubgroup.coe_eq_univ | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, ↑H = Set.univ ↔ H = ⊤ | true |
Lean.Elab.WF.GuessLex.RecCallWithContext.ctorIdx | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Elab.WF.GuessLex.RecCallWithContext → ℕ | false |
coe_ofLexAddEquiv | Mathlib.Algebra.Order.Group.Equiv | ∀ (α : Type u_1) [inst : Add α], ⇑(ofLexAddEquiv α) = ⇑ofLex | true |
FixedDetMatrices.reduce_rec | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | {m : ℤ} →
{C : FixedDetMatrix (Fin 2) ℤ m → Sort u_3} →
((A : FixedDetMatrix (Fin 2) ℤ m) → ↑A 1 0 = 0 → C A) →
((A : FixedDetMatrix (Fin 2) ℤ m) → ↑A 1 0 ≠ 0 → C (FixedDetMatrices.reduceStep A) → C A) →
(A : FixedDetMatrix (Fin 2) ℤ m) → C A | true |
IsStarProjection.of_one_sub | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p : R} [inst : NonAssocRing R] [inst_1 : StarRing R], IsStarProjection (1 - p) → IsStarProjection p | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.IsAtom.nonempty | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {K : ℝ} {A S : Finset G},
K < 1 → S.Nonempty → Finset.IsAtom✝ K S A → A.Nonempty | true |
SSet.Truncated.HomotopyCategory₂.Hom | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | {A : SSet.Truncated 2} → [A.Quasicategory₂] → A.HomotopyCategory₂ → A.HomotopyCategory₂ → Type u_1 | true |
MeasureTheory.Measure.AbsolutelyContinuous.refl | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {_m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α), μ.AbsolutelyContinuous μ | true |
Ideal.IsDedekindDomain.ramificationIdx_eq_normalizedFactors_count | Mathlib.NumberTheory.RamificationInertia.Ramification | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R} {P : Ideal S}
[inst_3 : IsDedekindDomain S],
Ideal.map (algebraMap R S) p ≠ ⊥ →
P.IsPrime →
P ≠ ⊥ →
p.ramificationIdx P =
Multiset.count P (UniqueFactorizationMonoid.normalizedFacto... | true |
pairSelfAdjointMatricesSubmodule.eq_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} [inst : CommRing R] [inst_1 : Fintype n] (J J₂ : Matrix n n R)
[inst_2 : DecidableEq n],
pairSelfAdjointMatricesSubmodule J J₂ =
Submodule.map (↑LinearMap.toMatrix')
(((Matrix.toLinearMap₂' R) J).isPairSelfAdjointSubmodule ((Matrix.toLinearMap₂' R) J₂)) | true |
Lean.Compiler.LCNF.Phase.le_refl | Lean.Compiler.LCNF.PassManager | ∀ (p : Lean.Compiler.LCNF.Phase), p ≤ p | true |
RootPairing.zero_lt_pairingIn_iff' | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (S : Type u_5)
[inst_5 : CommRing S] [inst_6 : LinearOrder S] [IsStrictOrderedRing S] [inst_8 : Algebra S R] [Fa... | true |
Std.Time.OffsetO.casesOn | Std.Time.Format.Basic | {motive : Std.Time.OffsetO → Sort u} →
(t : Std.Time.OffsetO) → motive Std.Time.OffsetO.short → motive Std.Time.OffsetO.full → motive t | false |
Array.getElem_insertIdx_of_gt | Init.Data.Array.InsertIdx | ∀ {α : Type u} {xs : Array α} {x : α} {i k : ℕ} (w : k ≤ xs.size) (h : k > i), (xs.insertIdx i x ⋯)[k] = xs[k - 1] | true |
rTensor_exact | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | true |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Presentation.Expr.2260322628._hygCtx._hyg.1.ctorIdx | ProofWidgets.Presentation.Expr | ProofWidgets.RpcEncodablePacket✝ → ℕ | false |
Finset.map_subtype_embedding_Ioo | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] (p : α → Prop) [inst_1 : DecidablePred p] [inst_2 : LocallyFiniteOrder α]
(a b : Subtype p),
(∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x) →
Finset.map (Function.Embedding.subtype p) (Finset.Ioo a b) = Finset.Ioo ↑a ↑b | true |
_private.Mathlib.FieldTheory.IsAlgClosed.Spectrum.0.spectrum.«_aux_Mathlib_FieldTheory_IsAlgClosed_Spectrum___macroRules__private_Mathlib_FieldTheory_IsAlgClosed_Spectrum_0_spectrum_term↑ₐ_1» | Mathlib.FieldTheory.IsAlgClosed.Spectrum | Lean.Macro | false |
CategoryTheory.IsCofiltered.toIsCofilteredOrEmpty | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.IsCofiltered C],
CategoryTheory.IsCofilteredOrEmpty C | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry!.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Inhabited (α × β)],
Std.DTreeMap.Internal.Impl.Const.maxEntry! Std.DTreeMap.Internal.Impl.leaf =
panicWithPosWithDecl "Std.Data.DTreeMap.Internal.Queries" "Std.DTreeMap.Internal.Impl.Const.maxEntry!" 839 13
"Map is empty" | true |
List.rotate'_nil | Mathlib.Data.List.Rotate | ∀ {α : Type u} (n : ℕ), [].rotate' n = [] | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.summable_cotTermUpperBound | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ (A B : ℝ) (hB : 0 < B) {k : ℕ}, 1 ≤ k → Summable fun a => cotTermUpperBound✝ k A B hB a | true |
Std.instTransCmpCompareOnOfTransOrd | Init.Data.Order.Ord | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : Ord β] [Std.TransOrd β], Std.TransCmp (compareOn f) | true |
Lean.Elab.Term.Do.JPDecl.mk._flat_ctor | Lean.Elab.Do.Legacy | Lean.Name → Array (Lean.Elab.Term.Do.Var × Bool) → Lean.Elab.Term.Do.Code → Lean.Elab.Term.Do.JPDecl | false |
Std.IterM.toList_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Option γ} (it : Std.IterM m β),
(Std.IterM.filterMap f it).toList = (fun x => List.filterMap f x) <$> it.toList | true |
FractionalIdeal.quotientEquiv._proof_10 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_2} [inst : CommRing R] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDedekindDomain R] (I I' J' : FractionalIdeal (nonZeroDivisors R) K),
↑(FractionalIdeal.spanSingleton (nonZeroDivisors R) (I'.divMod I J')) * ↑I ≤
↑(J' + FractionalIdeal.spanSin... | false |
USize.eq_sub_iff_add_eq | Init.Data.UInt.Lemmas | ∀ {a b c : USize}, a = c - b ↔ a + b = c | true |
OrthogonalFamily.decomposition._proof_2 | Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional | ∀ {𝕜 : Type u_3} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_1} [inst_3 : DecidableEq ι] [inst_4 : Fintype ι] {V : ι → Submodule 𝕜 E}
[inst_5 : ∀ (i : ι), CompleteSpace ↥(V i)],
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) →... | false |
Algebra.EssFiniteType.aux | Mathlib.RingTheory.EssentialFiniteness | ∀ (R : Type u_1) (S : Type u_2) (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T]
(σ : Subalgebra R S),
(∀ (s : S), ∃ t ∈ σ, IsUnit t ∧ s * t ∈ σ) →
∀ (τ : Set T),
∀ t ∈ Algeb... | true |
Std.ExtDTreeMap.getKey?_diff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, (t₁ \ t₂).getKey? k = if k ∈ t₂ then none else t₁.getKey? k | true |
FirstOrder.Language.Embedding.recOn | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{motive : L.Embedding M N → Sort u_1} →
(t : L.Embedding M N) →
((toEmbedding : M ↪ N) →
(map_fun' :
∀ {n : ℕ} (f... | false |
ContMDiff.smoothSheafHom | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_2} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_3} →
[inst_3 : TopologicalSpace HM] →
{IM : ModelWithCorners 𝕜 EM HM} →
{E : Type u_4} →
... | true |
BoxIntegral.TaggedPrepartition.unionComplToSubordinate | Mathlib.Analysis.BoxIntegral.Partition.SubboxInduction | {ι : Type u_1} →
[Fintype ι] →
{I : BoxIntegral.Box ι} →
(π₁ : BoxIntegral.TaggedPrepartition I) →
(π₂ : BoxIntegral.Prepartition I) →
π₂.iUnion = ↑I \ π₁.iUnion → ((ι → ℝ) → ↑(Set.Ioi 0)) → BoxIntegral.TaggedPrepartition I | true |
Bundle.Trivialization.rec | Mathlib.Topology.FiberBundle.Trivialization | {B : Type u_1} →
{F : Type u_2} →
{Z : Type u_4} →
[inst : TopologicalSpace B] →
[inst_1 : TopologicalSpace F] →
[inst_2 : TopologicalSpace Z] →
{proj : Z → B} →
{motive : Bundle.Trivialization F proj → Sort u} →
((toOpenPartialHomeomorph : OpenPar... | false |
Encodable | Mathlib.Logic.Encodable.Basic | Type u_1 → Type u_1 | true |
QuasispectrumRestricts.cfcₙ_eq_restrict | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} {p q : A → Prop} [inst : Semifield R] [inst_1 : StarRing R]
[inst_2 : MetricSpace R] [inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Field S]
[inst_6 : StarRing S] [inst_7 : MetricSpace S] [inst_8 : IsTopologicalRing S] [inst_9 : ContinuousStar... | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.aeval_eq_φ | Mathlib.Analysis.Normed.Algebra.GelfandMazur | ∀ {F : Type u_1} [inst : NormedRing F] [inst_1 : NormedAlgebra ℝ F] (x : F) (u : ℝ × ℝ),
(Polynomial.aeval x) (Polynomial.X ^ 2 - Polynomial.C u.1 * Polynomial.X + Polynomial.C u.2) =
NormedAlgebra.Real.φ✝ x u | true |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.Scheme.coprodPresheafObjIso_hom_fst._simp_1_2 | Mathlib.AlgebraicGeometry.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
Int8.toUInt8_not | Init.Data.SInt.Bitwise | ∀ (a : Int8), (~~~a).toUInt8 = ~~~a.toUInt8 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.