name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Set.ssubset_iff_exists | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ⊂ t ↔ s ⊆ t ∧ ∃ x ∈ t, x ∉ s | true |
Lean.Lsp.CallHierarchyPrepareParams.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.Position → Lean.Lsp.CallHierarchyPrepareParams | false |
_private.Batteries.Tactic.PrintPrefix.0.Batteries.Tactic.matchingConstants | Batteries.Tactic.PrintPrefix | Batteries.Tactic.PrintPrefixConfig → Lean.Name → Lean.MetaM (Array Lean.MessageData) | true |
TemperedDistribution.fourierMultiplierCLM_smul | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {E : Type u_3} {F : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : NormedSpace ℂ F] [inst_4 : FiniteDimensional ℝ E]
[inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] {g : E → ℂ},
Function.HasTemperateGrowth g →
∀ (c : ℂ), TemperedDistri... | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_45 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_41 →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_43 → r₀ ≤ r' | false |
Matroid.IsRkFinite.isRkFinite_diff_iff | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X Y : Set α}, M.IsRkFinite X → (M.IsRkFinite (Y \ X) ↔ M.IsRkFinite Y) | true |
CategoryTheory.Abelian.SpectralObject.opcyclesMap_fromOpcycles_assoc | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) {i' j' k' : ι} (f' : i' ⟶ j')
(g' : j' ⟶ k') (fg : i ⟶ k) (h : Categ... | true |
Ideal.quotientEquiv._proof_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : Ring R] {S : Type u_2} [inst_1 : Ring S], RingHomClass (R ≃+* S) R S | false |
AddOpposite.unop_eq_zero_iff._simp_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Zero α] (a : αᵃᵒᵖ), (AddOpposite.unop a = 0) = (a = 0) | false |
_private.Mathlib.Analysis.Calculus.LogDeriv.0.AnalyticAt.tendsto_mul_logDeriv_simple_zero._simp_1_3 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
BitVec.reduceClz | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | true |
DividedPowers.IsDPMorphism.on_span | Mathlib.RingTheory.DividedPowers.DPMorphism | ∀ {A : Type u_3} {B : Type u_4} [inst : CommSemiring A] [inst_1 : CommSemiring B] {I : Ideal A} {J : Ideal B}
(hI : DividedPowers I) (hJ : DividedPowers J) {f : A →+* B} {S : Set A},
I = Ideal.span S → (∀ s ∈ S, f s ∈ J) → (∀ {n : ℕ}, ∀ a ∈ S, f (hI.dpow n a) = hJ.dpow n (f a)) → hI.IsDPMorphism hJ f | true |
AlgebraicTopology.DoldKan.N₁Γ₀ | Mathlib.AlgebraicTopology.DoldKan.GammaCompN | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] →
AlgebraicTopology.DoldKan.Γ₀.comp AlgebraicTopology.DoldKan.N₁ ≅
CategoryTheory.Idempotents.toKaroubi (ChainComplex C ℕ) | true |
AlgebraicClosure.instCommRing._proof_31 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k],
autoParam
(∀ (n : ℕ) (x : AlgebraicClosure k),
AlgebraicClosure.instCommRing._aux_28 k (n + 1) x = AlgebraicClosure.instCommRing._aux_28 k n x * x)
Monoid.npow_succ._autoParam | false |
AffineSubspace.isPreconnected_setOf_sOppSide | Mathlib.Analysis.Convex.Side | ∀ {V : Type u_2} {P : Type u_4} [inst : SeminormedAddCommGroup V] [inst_1 : NormedSpace ℝ V]
[inst_2 : PseudoMetricSpace P] [inst_3 : NormedAddTorsor V P] (s : AffineSubspace ℝ P) (x : P),
IsPreconnected {y | s.SOppSide x y} | true |
add_lt_of_lt_neg_add | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, b < -a + c → a + b < c | true |
Finsupp.sumFinsuppEquivProdFinsupp_symm_inl | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_12} {β : Type u_13} {γ : Type u_14} [inst : Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) (x : α),
(Finsupp.sumFinsuppEquivProdFinsupp.symm fg) (Sum.inl x) = fg.1 x | true |
inv_eq_one._simp_2 | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] {a : α}, (a⁻¹ = 1) = (a = 1) | false |
AlgebraicGeometry.IsAffineOpen.arrowStalkMapIso._simp_1 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), (↑e).symm = ↑e.symm | false |
_private.Lean.Elab.RecommendedSpelling.0.Lean.Elab.Term.Doc.elabRecommendedSpelling.match_1 | Lean.Elab.RecommendedSpelling | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((decls : Array (Lean.TSyntax `ident)) → motive (some decls)) → (Unit → motive none) → motive x | false |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0._aux_Mathlib_NumberTheory_ModularForms_DedekindEta___macroRules__private_Mathlib_NumberTheory_ModularForms_DedekindEta_0_term𝕢_1 | Mathlib.NumberTheory.ModularForms.DedekindEta | Lean.Macro | false |
Lean.Grind.AC.Seq.noConfusion | Init.Grind.AC | {P : Sort u} → {t t' : Lean.Grind.AC.Seq} → t = t' → Lean.Grind.AC.Seq.noConfusionType P t t' | false |
BitVec.le_refl._simp_1 | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : BitVec n), (x ≤ x) = True | false |
HasStrictFDerivAt.fun_pow' | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} {E : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedAlgebra 𝕜 𝔸] [inst_4 : NormedSpace 𝕜 E] {f : E → 𝔸} {f' : E →L[𝕜] 𝔸}
{x : E},
HasStrictFDerivAt f f' x →
∀ (n : ℕ),
HasStrictFDerivAt (fun x... | true |
CategoryTheory.AsSmall.equiv | Mathlib.CategoryTheory.Category.ULift | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → C ≌ CategoryTheory.AsSmall C | true |
_private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.mem_finPairsLT._simp_1_6 | Mathlib.GroupTheory.Perm.Sign | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Finset ι} {t : (i : ι) → Finset (α i)} {a : (i : ι) × α i},
(a ∈ s.sigma t) = (a.fst ∈ s ∧ a.snd ∈ t a.fst) | false |
CategoryTheory.ObjectProperty.IsStrongGenerator.subobject_eq_top | Mathlib.CategoryTheory.Generator.StrongGenerator | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C},
P.IsStrongGenerator →
∀ {X : C} {A : CategoryTheory.Subobject X}, (∀ (G : C), P G → ∀ (f : G ⟶ X), A.Factors f) → A = ⊤ | true |
Valued.valueGroup₀_equiv_extensionValuation._proof_2 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {K : Type u_2} [inst : Field K] {Γ₀ : Type u_1} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀],
Function.Injective ⇑Valued.valueGroup₀_hom_extensionValuation ∧
Function.Surjective ⇑Valued.valueGroup₀_hom_extensionValuation | false |
CategoryTheory.Idempotents.DoldKan.Γ_map_app | Mathlib.AlgebraicTopology.DoldKan.EquivalencePseudoabelian | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.IsIdempotentComplete C] [inst_3 : CategoryTheory.Limits.HasFiniteCoproducts C]
{X Y : ChainComplex C ℕ} (f : X ⟶ Y) (Δ : SimplexCategoryᵒᵖ),
(CategoryTheory.Idempotents.DoldKan.Γ.map f).... | true |
MeasureTheory.charFun_eq_fourierIntegral | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {E : Type u_2} {mE : MeasurableSpace E} {μ : MeasureTheory.Measure E} [inst : SeminormedAddCommGroup E]
[inst_1 : InnerProductSpace ℝ E] (t : E),
MeasureTheory.charFun μ t = VectorFourier.fourierIntegral Real.probChar μ (innerₗ E) 1 (-t) | true |
_private.Lean.Compiler.IR.EmitC.0.Lean.IR.EmitC.isTailCall._sparseCasesOn_2 | Lean.Compiler.IR.EmitC | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.Arg) → motive_2 (Lean.IR.FnBody.ret x)) → (Nat.hasNotBit 1024 t.ctorIdx → motive_2 t) → motive_2 t | false |
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalWithAnnotateState._regBuiltin._private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalWithAnnotateState_1 | Lean.Elab.Tactic.Grind.BuiltinTactic | IO Unit | false |
_private.Std.Data.DHashMap.Internal.WF.0.List.forIn'_cons.match_1.splitter | Std.Data.DHashMap.Internal.WF | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(x : ForInStep β) → ((b : β) → motive (ForInStep.done b)) → ((b : β) → motive (ForInStep.yield b)) → motive x | true |
Mathlib.Deriving.Traversable.mkCasesOnMatch | Mathlib.Tactic.DeriveTraversable | Lean.Name →
List Lean.Level →
List Lean.Expr →
Lean.Expr →
List Lean.Expr →
Lean.Expr → (Lean.Name → List Lean.FVarId → Lean.Elab.TermElabM Lean.Expr) → Lean.Elab.TermElabM Lean.Expr | true |
UniformEquicontinuousOn | Mathlib.Topology.UniformSpace.Equicontinuity | {ι : Type u_1} →
{α : Type u_6} → {β : Type u_8} → [uα : UniformSpace α] → [uβ : UniformSpace β] → (ι → β → α) → Set β → Prop | true |
DualNumber.commute_eps_left | Mathlib.Algebra.DualNumber | ∀ {R : Type u_1} [inst : Semiring R] (x : DualNumber R), Commute DualNumber.eps x | true |
TopologicalSpace.IsCompletelyPseudoMetrizableSpace.pi_countable | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {ι : Type u_3} [Countable ι] {X : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (X i)]
[∀ (i : ι), TopologicalSpace.IsCompletelyPseudoMetrizableSpace (X i)],
TopologicalSpace.IsCompletelyPseudoMetrizableSpace ((i : ι) → X i) | true |
Lean.Widget.RpcEncodablePacket.mk.inj._@.Lean.Server.FileWorker.WidgetRequests.1564534894._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | ∀ {kind info kind_1 info_1 : Lean.Json},
{ kind := kind, info := info } = { kind := kind_1, info := info_1 } → kind = kind_1 ∧ info = info_1 | false |
Lean.RBNode.balLeft | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → Lean.RBNode α β → (k : α) → β k → Lean.RBNode α β → Lean.RBNode α β | true |
Order.mem_range_succ_of_not_isSuccPrelimit | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : SuccOrder α],
¬Order.IsSuccPrelimit a → a ∈ Set.range Order.succ | true |
normEDS_zero | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), normEDS b c d 0 = 0 | true |
NormedAddGroupHom.add._proof_3 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_1} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f g : NormedAddGroupHom V₁ V₂) (v : V₁), ‖f v + g v‖ ≤ (‖f‖ + ‖g‖) * ‖v‖ | false |
LieSubmodule.copy | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : LieRingModule L M] → (N : LieSubmodule R L M) → (s : Set M) → s = ↑N → LieSubmodule R L M | true |
Int.mul_self_le_mul_self | Init.Data.Int.Order | ∀ {a b : ℤ}, 0 ≤ a → a ≤ b → a * a ≤ b * b | true |
Lean.Meta.Grind.AC.ACM.Context.ctorIdx | Lean.Meta.Tactic.Grind.AC.Util | Lean.Meta.Grind.AC.ACM.Context → ℕ | false |
ENat.card_lt_top._simp_1 | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1}, (ENat.card α < ⊤) = Finite α | false |
bihimp_of_ge | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, b ≤ a → bihimp a b = a ⇨ b | true |
CategoryTheory.BimonObj.one_comul | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} (M : C) [self : CategoryTheory.BimonObj M],
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one CategoryTheory.ComonObj.comul = CategoryTheory.MonObj.one | true |
SeminormedAddGroup.toContinuousENorm._proof_1 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_1} [inst : SeminormedAddGroup E], Continuous (ENNReal.ofNNReal ∘ nnnorm) | false |
MulArchimedeanClass.instSubsingleton | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] [Subsingleton M],
Subsingleton (MulArchimedeanClass M) | true |
Lean.Lsp.Ipc.CallHierarchy.casesOn | Lean.Data.Lsp.Ipc | {motive_1 : Lean.Lsp.Ipc.CallHierarchy → Sort u} →
(t : Lean.Lsp.Ipc.CallHierarchy) →
((item : Lean.Lsp.CallHierarchyItem) →
(fromRanges : Array Lean.Lsp.Range) →
(children : Array Lean.Lsp.Ipc.CallHierarchy) →
motive_1 { item := item, fromRanges := fromRanges, children := children }... | false |
MeasureTheory.Measure.FiniteAtFilter.filterSup | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : Filter α},
μ.FiniteAtFilter f → μ.FiniteAtFilter g → μ.FiniteAtFilter (f ⊔ g) | true |
QuadraticAlgebra.instNeg | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} → {a b : R} → [Neg R] → Neg (QuadraticAlgebra R a b) | true |
_private.Mathlib.Topology.AlexandrovDiscrete.0.isOpen_iff_forall_specializes._simp_1_4 | Mathlib.Topology.AlexandrovDiscrete | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
Metric.Sum.dist.eq_4 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u} {Y : Type v} [inst : MetricSpace X] [inst_1 : MetricSpace Y] (x_2 : Y) (y : X),
Metric.Sum.dist (Sum.inr x_2) (Sum.inl y) = dist x_2 ⋯.some + 1 + dist ⋯.some y | true |
List.dropWhile_cons_of_pos | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, p a = true → List.dropWhile p (a :: l) = List.dropWhile p l | true |
Std.Time.Year.Era.bce.sizeOf_spec | Std.Time.Date.Unit.Year | sizeOf Std.Time.Year.Era.bce = 1 | true |
BoundedContinuousFunction.norm_eq | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
(f : BoundedContinuousFunction α β), ‖f‖ = sInf {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} | true |
QuadraticMap.Isometry.toLinearMap_injective | Mathlib.LinearAlgebra.QuadraticForm.Isometry | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} {N : Type u_7} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid N] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R N] {Q₁ : QuadraticMap R M₁ N} {Q₂ : QuadraticMap R M₂ N},
Function.Injective Q... | true |
Lean.pp.fvars.anonymous | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool | true |
FP.instInhabitedFloat | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → Inhabited FP.Float | true |
IsOrderedVAdd.vadd_le_vadd_left | Mathlib.Algebra.Order.AddTorsor | ∀ {G : Type u_3} {P : Type u_4} {inst : LE G} {inst_1 : LE P} {inst_2 : VAdd G P} [self : IsOrderedVAdd G P] (a b : P),
a ≤ b → ∀ (c : G), c +ᵥ a ≤ c +ᵥ b | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_554 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h :
List.idxOfNth w [g (g a)] [g (g a)].length + 1 ≤ (List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w [g (g a)] [g (g a)].length] <
[g... | false |
Polynomial.eval_eq_sum_degreeLTEquiv | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {n : ℕ} {p : Polynomial R} (hp : p ∈ Polynomial.degreeLT R n) (x : R),
Polynomial.eval x p = ∑ i, (Polynomial.degreeLTEquiv R n) ⟨p, hp⟩ i * x ^ ↑i | true |
Int.negSucc_mul_subNatNat | Init.Data.Int.Lemmas | ∀ (m n k : ℕ), Int.negSucc m * Int.subNatNat n k = Int.subNatNat (m.succ * k) (m.succ * n) | true |
_private.Qq.Macro.0.Qq.Impl.quoteExpr.match_8 | Qq.Macro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((i : ℕ) → motive (Lean.Expr.bvar i)) →
((e : Lean.Expr) →
(fvarId : Lean.FVarId) →
(h : e = Lean.Expr.fvar fvarId) → motive (namedPattern e (Lean.Expr.fvar fvarId) h)) →
((e : Lean.Expr) →
(mvarId : Lean.MVarId) →... | false |
CasesInfo.mk.noConfusion | Lean.Meta.CasesInfo | {P : Sort u} →
{declName indName : Lean.Name} →
{arity discrPos : ℕ} →
{altsRange : Std.Rco ℕ} →
{altNumParams : Array CasesAltInfo} →
{declName' indName' : Lean.Name} →
{arity' discrPos' : ℕ} →
{altsRange' : Std.Rco ℕ} →
{altNumParams' : Array Cas... | false |
Finset.zero_mem_smul_finset | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : Zero β] [inst_2 : SMulZeroClass α β] {t : Finset β}
{a : α}, 0 ∈ t → 0 ∈ a • t | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Basic.0.Bundle.Trivialization.contMDiffOn_symm_trans._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {x : B × F}, (x ∈ e.target) = (x.1 ∈ e.baseSet) | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.inv_invApp._proof_2 | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
(U : TopologicalSpace.Opens ↑X.toTopCat),
(TopologicalSpace.Opens.map f.base).op.obj
(Opposite.op ((AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor f).obj U)) =
Opposit... | false |
Lean.Elab.ComputedFields.Context | Lean.Elab.ComputedFields | Type | true |
Cardinal.le_sum | Mathlib.SetTheory.Cardinal.Order | ∀ {ι : Type u} (f : ι → Cardinal.{max u v}) (i : ι), f i ≤ Cardinal.sum f | true |
Polynomial.erase_mem_lifts | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} [inst : Semiring R] {S : Type v} [inst_1 : Semiring S] {f : R →+* S} {p : Polynomial S} (n : ℕ),
p ∈ Polynomial.lifts f → Polynomial.erase n p ∈ Polynomial.lifts f | true |
SchwartzMap.lineDerivOpCLM_eq | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ (𝕜 : Type u_2) {E : Type u_5} {F : Type u_8} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace ℝ F] [inst_3 : NormedSpace ℝ E] [inst_4 : RCLike 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] (m : E),
LineDeriv.lineDerivOpCLM 𝕜 (SchwartzMap E F) m = (SchwartzM... | true |
EuclideanGeometry.orthogonalProjection_vadd_smul_vsub_orthogonalProjection | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] {s : AffineSubspace 𝕜 P}
[inst_5 : Nonempty ↥s] [inst_6 : s.direction.HasOrthogonalProjection] {p₁ : P} (p₂ : P) (r : 𝕜) (hp ... | true |
CategoryTheory.MonoidalCategory.DayConvolution._aux_Mathlib_CategoryTheory_Monoidal_DayConvolution___unexpand_CategoryTheory_MonoidalCategory_DayConvolution_convolution_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Order.Bounded.0.Set.Unbounded.rel_mono.match_1_1 | Mathlib.Order.Bounded | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} (a : α) (motive : (∃ b ∈ s, ¬r b a) → Prop) (x : ∃ b ∈ s, ¬r b a),
(∀ (b : α) (hb : b ∈ s) (hba : ¬r b a), motive ⋯) → motive x | false |
Lean.Meta.Sym.ProofInstInfo.recOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.ProofInstInfo → Sort u} →
(t : Lean.Meta.Sym.ProofInstInfo) →
((argsInfo : Array Lean.Meta.Sym.ProofInstArgInfo) → motive { argsInfo := argsInfo }) → motive t | false |
Algebra.IsIntegral.recOn | Mathlib.RingTheory.IntegralClosure.Algebra.Defs | {R : Type u_1} →
{A : Type u_3} →
[inst : CommRing R] →
[inst_1 : Ring A] →
[inst_2 : Algebra R A] →
{motive : Algebra.IsIntegral R A → Sort u} →
(t : Algebra.IsIntegral R A) → ((isIntegral : ∀ (x : A), IsIntegral R x) → motive ⋯) → motive t | false |
LowerSet.mem_mk._simp_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : Set α} (hs : IsLowerSet s) {a : α}, (a ∈ { carrier := s, lower' := hs }) = (a ∈ s) | false |
Topology.RelCWComplex.mem_skeleton_iff | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D] {n : ℕ∞}
{x : X},
x ∈ Topology.RelCWComplex.skeleton C n ↔ x ∈ D ∨ ∃ m, ∃ (_ : ↑m ≤ n), ∃ j, x ∈ Topology.RelCWComplex.openCell m j | true |
Lean.Meta.backward.inferInstanceAs.wrap.reuseSubInstances | Lean.Meta.WrapInstance | Lean.Option Bool | true |
CategoryTheory.FunctorToTypes.prod_ext | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} {a : C}
(z w : (CategoryTheory.FunctorToTypes.prod F G).obj a), z.1 = w.1 → z.2 = w.2 → z = w | true |
subset_tsupport | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_1} {α : Type u_2} [inst : Zero α] [inst_1 : TopologicalSpace X] (f : X → α),
Function.support f ⊆ tsupport f | true |
Mathlib.Tactic.BicategoryLike.MkEvalWhiskerRight.mk | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
(Mathlib.Tactic.BicategoryLike.WhiskerRight → Mathlib.Tactic.BicategoryLike.Atom₁ → m Lean.Expr) →
(Mathlib.Tactic.BicategoryLike.Atom₁ →
Mathlib.Tactic.BicategoryLike.WhiskerRight →
Mathlib.Tactic.BicategoryLike.HorizontalComp →
Mathlib.Tactic.BicategoryLike.Norm... | true |
Std.Iter.Total.toExtTreeSet._auto_1 | Std.Data.Iterators.Consumers.Set | Lean.Syntax | false |
IsLUB.iUnion_Iio_eq | Mathlib.Order.Interval.Set.Disjoint | ∀ {ι : Sort u} {α : Type v} [inst : LinearOrder α] {a : α} {f : ι → α},
IsLUB (Set.range f) a → ⋃ x, Set.Iio (f x) = Set.Iio a | true |
Vector.findSomeM?_mk | Init.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {n : ℕ} {β : Type u_1} [inst : Monad m] {xs : Array α} (h : xs.size = n)
(f : α → m (Option β)), Vector.findSomeM? f (Vector.mk xs h) = Array.findSomeM? f xs | true |
Std.TreeSet.le_max!_of_contains | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
t.contains k = true → (cmp k t.max!).isLE = true | true |
Lean.ClassEntry.recOn | Lean.Class | {motive : Lean.ClassEntry → Sort u} →
(t : Lean.ClassEntry) →
((name : Lean.Name) →
(outParams outLevelParams : Array ℕ) →
motive { name := name, outParams := outParams, outLevelParams := outLevelParams }) →
motive t | false |
Metric.unitSphere.instMonoid._proof_11 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedRing 𝕜] [inst_1 : NormMulClass 𝕜] [inst_2 : NormOneClass 𝕜],
autoParam
(∀ (n : ℕ) (x : ↑(Metric.sphere 0 1)),
Metric.unitSphere.instMonoid._aux_8 (n + 1) x = Metric.unitSphere.instMonoid._aux_8 n x * x)
Monoid.npow_succ._autoParam | false |
ContinuousAdd.to_continuousVAdd | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M], ContinuousVAdd M M | true |
Std.Slice.Internal.toArray_eq_toArray_iter | Init.Data.Slice.InternalLemmas | ∀ {γ : Type u} {α β : Type v} {s : Std.Slice γ} [inst : Std.ToIterator (Std.Slice γ) Id α β]
[inst_1 : Std.Iterator α Id β] [Std.Iterators.Finite α Id], s.toArray = (Std.Slice.Internal.iter s).toArray | true |
MeasureTheory.AEDisjoint.exists_disjoint_diff | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.AEDisjoint μ s t → ∃ u, MeasurableSet u ∧ μ u = 0 ∧ Disjoint (s \ u) t | true |
Set.OrdConnected.isStronglyCoatomic | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : Preorder α] [IsStronglyCoatomic α] {s : Set α}, s.OrdConnected → IsStronglyCoatomic ↑s | true |
ArchimedeanClass.mk_mul | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] (x y : R),
ArchimedeanClass.mk (x * y) = ArchimedeanClass.mk x + ArchimedeanClass.mk y | true |
HomotopicalAlgebra.Precylinder.LeftHomotopy.refl | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → (P : HomotopicalAlgebra.Precylinder X) → {Y : C} → (f : X ⟶ Y) → P.LeftHomotopy f f | true |
EMetric.isUniformEmbedding_iff | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
IsUniformEmbedding f ↔
Function.Injective f ∧ UniformContinuous f ∧ ∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ | true |
AlternativeMonad.toBind | Batteries.Control.AlternativeMonad | {m : Type u_1 → Type u_2} → [self : AlternativeMonad m] → Bind m | true |
Empty.rec | Init.Prelude | (motive : Empty → Sort u) → (t : Empty) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.