name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Server.ModuleRefs.addRef | Lean.Server.References | Lean.Server.ModuleRefs → Lean.Server.Reference → Lean.Server.ModuleRefs | Adds `ref` to the `RefInfo` corresponding to `ref.ident` in `self`. See `RefInfo.addRef`. | true |
Set.powersetCard.instAddActionElemFinset._proof_3 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_2) [inst : AddGroup G] {α : Type u_1} [inst_1 : AddAction G α] {n : ℕ} [inst_2 : DecidableEq α] (x y : G)
(b : ↑(Set.powersetCard α n)), (x + y) +ᵥ b = x +ᵥ y +ᵥ b | null | false |
exists_eq_iInf_of_not_isPredPrelimit | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {ι : Sort u_1} {α : Type u_2} [inst : CompleteLinearOrder α] {f : ι → α},
¬Order.IsPredPrelimit (⨅ i, f i) → ∃ i, f i = ⨅ i, f i | null | true |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Order.0.measure_eq_measure_preimage_add_measure_tsum_Ico_zpow._simp_1_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
instSMulCommClassUniformOnFun | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} {M : Type u_4} {N : Type u_5} [inst : SMul M β] [inst_1 : SMul N β]
[SMulCommClass M N β], SMulCommClass M N (UniformOnFun α β 𝔖) | null | true |
Nat.Partrec.Code.ofNatCode._unsafe_rec | Mathlib.Computability.PartrecCode | ℕ → Nat.Partrec.Code | null | false |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.instBEqSearchStep.beq._sparseCasesOn_2 | Init.Data.String.Pattern.Basic | {s : String.Slice} →
{motive : String.Slice.Pattern.SearchStep s → Sort u} →
(t : String.Slice.Pattern.SearchStep s) →
((startPos endPos : s.Pos) → motive (String.Slice.Pattern.SearchStep.matched startPos endPos)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Matrix.PosDef.posSemidef_add | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {m : Type u_1} {R : Type u_3} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [AddLeftMono R]
{A B : Matrix m m R}, A.PosSemidef → B.PosDef → (A + B).PosDef | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_16 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ (m n k : ℕ), k + m ≤ n → ∀ (j₂ : Fin m), ↑j₂ + 1 ≤ m → ↑j₂ + k < n | null | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.applyPartition_eq._simp_1_6 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
Lean.Json.Parser.natCoreNumDigits | Lean.Data.Json.Parser | ℕ → ℕ → Std.Internal.Parsec.String.Parser (ℕ × ℕ) | null | true |
TopologicalSpace.OpenNhdsOf.instPartialOrder._proof_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} (a : TopologicalSpace.OpenNhdsOf x), a ≤ a | null | false |
AddSubsemigroup.copy | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_1} → [inst : Add M] → (S : AddSubsemigroup M) → (s : Set M) → s = ↑S → AddSubsemigroup M | Copy an additive subsemigroup replacing `carrier` with a set that is equal to it. | true |
Aesop.BaseRuleSetMember.unfoldRule.inj | Aesop.RuleSet.Member | ∀ {r r_1 : Aesop.UnfoldRule}, Aesop.BaseRuleSetMember.unfoldRule r = Aesop.BaseRuleSetMember.unfoldRule r_1 → r = r_1 | null | true |
LinearMap.toContinuousLinearMap._proof_9 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type u_3}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst... | null | false |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandSafePrefixGoal._unsafe_rec | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.GoalRef → Aesop.SafeExpansionM Q Unit | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_55 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w w_1 n : ℕ) (h : w = w_1 * n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (expr : aig_1.RefVec w_1)
(haig : aig.decls.size ≤ { aig := aig_1, vec := expr }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExp... | null | false |
ZNum.abs_toZNum | Mathlib.Data.Num.ZNum | ∀ (n : Num), n.toZNum.abs = n | null | true |
Std.DTreeMap.Raw.isEmpty_eq_false_iff_exists_mem | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → (t.isEmpty = false ↔ ∃ a, a ∈ t) | null | true |
Array.map_fst_zip | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array β}, as.size ≤ bs.size → Array.map Prod.fst (as.zip bs) = as | null | true |
NonUnitalRingHom.srangeRestrict_surjective | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] (f : R →ₙ+* S),
Function.Surjective ⇑f.srangeRestrict | null | true |
HasStrictDerivAt.const_cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {f : ℂ → ℂ} {f' x c : ℂ},
HasStrictDerivAt f f' x → c ≠ 0 ∨ f x ≠ 0 → HasStrictDerivAt (fun x => c ^ f x) (c ^ f x * Complex.log c * f') x | null | true |
Vector.instDecidableLTOfDecidableEq._proof_1 | Init.Data.Vector.Lex | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] [inst_1 : LT α] [inst_2 : DecidableLT α] (xs ys : Vector α n),
(xs.lex ys fun x1 x2 => decide (x1 < x2)) = true ↔ xs < ys | null | false |
Set.Infinite.eq_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} (s : Set α), s.Infinite = ¬s.Finite | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₂_eq_some_of_toBitVec._simp_1_7 | Init.Data.String.Decode | ∀ {n : ℕ} {x y : BitVec n}, (x < y) = (x.toNat < y.toNat) | null | false |
«_aux_Mathlib_Algebra_Symmetrized___macroRules_term_ˢʸᵐ_1» | Mathlib.Algebra.Symmetrized | Lean.Macro | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastReplicate.go_get_aux._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (n : ℕ) (input : aig.RefVec w)
(idx : ℕ) (_x : (curr : ℕ) ×' (_ : curr ≤ n) ×' (_ : aig.RefVec (w * curr)) ×' idx < w * curr),
(Std.Tactic.BVDecide.BVExpr.bitblast.blastReplicate.go n input _x.1 ⋯ _x.2.2.1).get idx ⋯ = _x.2.2.1.... | null | false |
AddCommMonCat.addCommMonoidObj._proof_11 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddCommMonCat) (j : J),
autoParam (∀ (n : ℕ) (x : (F.comp (CategoryTheory.forget AddCommMonCat)).obj j), (n + 1) • x = n • x + x)
AddMonoid.nsmul_succ._autoParam | null | false |
Lean.MetavarContext.instanceTypedMVars._default | Lean.MetavarContext | Lean.PersistentHashMap Lean.MVarId Unit | null | false |
div_mul_div_cancel | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a b c : G), a / b * (b / c) = a / c | null | true |
Ring.inverse_eq_inv' | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀], Ring.inverse = Inv.inv | null | true |
Nat.instDiv | Init.Prelude | Div ℕ | null | true |
ContinuousAt.cfcₙ_nnreal | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {X : Type u_1} {A : Type u_2} [inst : NonUnitalNormedRing A] [inst_1 : StarRing A] [inst_2 : NormedSpace ℝ A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : SMulCommClass ℝ A A] [ContinuousStar A]
[inst_6 : NonUnitalIsometricContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A]
[inst_8 : StarOrder... | If `f : ℝ≥0 → ℝ≥0` is continuous on a compact set `s` and `f 0 = 0` and `a : X → A` is
continuous at `x₀`, and eventually `0 ≤ a x` and has quasispectrum contained in `s`, then
`fun x ↦ cfcₙ f (a x)` is continuous at `x₀`. | true |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.liftMetaTactic1.match_1 | Lean.Elab.Tactic.Basic | (motive : Option Lean.MVarId → Sort u_1) →
(__do_lift : Option Lean.MVarId) →
((mvarId : Lean.MVarId) → motive (some mvarId)) → ((x : Option Lean.MVarId) → motive x) → motive __do_lift | null | false |
HomologicalComplex₂.d₁_eq' | Mathlib.Algebra.Homology.TotalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {I₁ : Type u_2}
{I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K : HomologicalComplex₂ C c₁ c₂)
(c₁₂ : ComplexShape I₁₂) [inst_2 : TotalComplexShape c₁ c₂ c₁₂] [inst_3 : DecidableE... | null | true |
CategoryTheory.Iso.commGroupIsoToMulEquiv._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : CommGrpCat} (i : X ≅ Y), (CommGrpCat.Hom.hom i.hom).comp (CommGrpCat.Hom.hom i.inv) = MonoidHom.id ↑Y | null | false |
RelIso.sumLexComplLeft._proof_1 | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} (r : α → α → Prop) (x : α) [IsTrans α r] [Std.Trichotomous r] [inst : DecidableRel r]
{a b : { x_1 // r x_1 x } ⊕ { x_1 // ¬r x_1 x }},
r ((Equiv.sumCompl fun x_1 => r x_1 x) a) ((Equiv.sumCompl fun x_1 => r x_1 x) b) ↔
Sum.Lex (Subrel r fun x_1 => r x_1 x) (Subrel r fun x_1 => ¬r x_1 x) a b | null | false |
SSet.StrictSegalCore.ctorIdx | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} → {n : ℕ} → X.StrictSegalCore n → ℕ | null | false |
CategoryTheory.Monoidal.Transported | Mathlib.CategoryTheory.Monoidal.Transport | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → (C ≌ D) → Type u₂ | A type synonym for `D`, which will carry the transported monoidal structure. | true |
Mathlib.Tactic.ClickSuggestions.SectionState.ctorIdx | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} → Mathlib.Tactic.ClickSuggestions.SectionState α → ℕ | null | false |
Rat.smul_def | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_1} [inst : DivisionRing K] (a : ℚ) (x : K), a • x = ↑a * x | null | true |
Set.mapsTo_iInter | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} {s : Set α} {t : ι → Set β} {f : α → β},
Set.MapsTo f s (⋂ i, t i) ↔ ∀ (i : ι), Set.MapsTo f s (t i) | null | true |
Int16.decEq.match_1 | Init.Data.SInt.Basic | (motive : Int16 → Int16 → Sort u_1) →
(a b : Int16) → ((n m : UInt16) → motive { toUInt16 := n } { toUInt16 := m }) → motive a b | null | false |
MeasureTheory.stronglyAdapted_predictablePart | Mathlib.Probability.Martingale.Centering | ∀ {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] {f : ℕ → Ω → E} {ℱ : MeasureTheory.Filtration ℕ m0},
MeasureTheory.StronglyAdapted ℱ fun n => MeasureTheory.predictablePart f ℱ μ (n + 1) | null | true |
PresheafOfModules.instAddCommGroupModuleColimit._proof_21 | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{cR : CategoryTheory.Limits.Cocone R} (hcR : CategoryTheory.Limits.IsColimit cR) {M : PresheafOfModules R}
{cM : CategoryTheory.Limits.Cocone M.presheaf} (hcM : CategoryTheory.Limits.IsColimit cM),
autoParam (∀... | null | false |
Std.DHashMap.Internal.Raw₀.Const.all_eq_false | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] {p : α → β → Bool},
(↑m).WF →
((↑m).all p = false ↔
∃ a, ∃ (h : m.contains a = true), p (m.getKey a h) (Std.DHashMap.Internal.Raw₀.Const.get m a h) = false) | null | true |
_private.Lean.Meta.CtorIdxHInj.0.Lean.Meta.initFn._sparseCasesOn_1._@.Lean.Meta.CtorIdxHInj.1686831688._hygCtx._hyg.2 | Lean.Meta.CtorIdxHInj | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lean.Meta.FunInfo.ctorIdx | Lean.Meta.Basic | Lean.Meta.FunInfo → ℕ | null | false |
StableUnderSpecialization.compl | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, StableUnderSpecialization s → StableUnderGeneralization sᶜ | **Alias** of the reverse direction of `stableUnderGeneralization_compl_iff`. | true |
_private.Mathlib.RingTheory.LocalRing.Module.0.IsLocalRing.split_injective_iff_lTensor_residueField_injective._proof_1_4 | Mathlib.RingTheory.LocalRing.Module | 2 ≠ 0 | null | false |
MeasureTheory.Measure.mapₗ_mk_apply_of_aemeasurable | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{f : α → β} (hf : AEMeasurable f μ),
(MeasureTheory.Measure.mapₗ (AEMeasurable.mk f hf)) μ = MeasureTheory.Measure.map f μ | null | true |
FintypeCat.equivEquivIso_apply_inv | Mathlib.CategoryTheory.FintypeCat | ∀ {A B : FintypeCat} (e : A.obj ≃ B.obj), (FintypeCat.equivEquivIso e).inv = FintypeCat.homMk ⇑e.symm | null | true |
UniformSpace.Completion.coe_neg._simp_1 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_3} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] (a : α), -↑a = ↑(-a) | null | false |
Opens.mayerVietorisSquare'._proof_2 | Mathlib.Topology.Sheaves.MayerVietoris | ∀ {T : Type u_1} [inst : TopologicalSpace T], CategoryTheory.HasWeakSheafify (Opens.grothendieckTopology T) (Type u_1) | null | false |
Pi.Colex.instCompleteLinearOrderColexForall | Mathlib.Order.CompleteLattice.PiLex | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : LinearOrder ι] →
[(i : ι) → CompleteLinearOrder (α i)] → [WellFoundedGT ι] → CompleteLinearOrder (Colex ((i : ι) → α i)) | null | true |
AddAction.orbitZMultiplesEquiv | Mathlib.Data.ZMod.QuotientGroup | {α : Type u_4} →
{β : Type u_5} →
[inst : AddGroup α] →
(a : α) →
[inst_1 : AddAction α β] →
(b : β) →
↑(AddAction.orbit (↥(AddSubgroup.zmultiples a)) b) ≃ ZMod (Function.minimalPeriod (fun x => a +ᵥ x) b) | The orbit `(ℤ • a) +ᵥ b` is a cycle of order `minimalPeriod (a +ᵥ ·) b`. | true |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Elab.Tactic.parseModifier | Lean.Elab.Tactic.Grind.Param | String → Lean.CoreM Lean.Meta.Grind.AttrKind | null | true |
IsRegular.left | Mathlib.Algebra.Regular.Defs | ∀ {R : Type u_1} [inst : Mul R] {c : R}, IsRegular c → IsLeftRegular c | A regular element `c` is left-regular | true |
CategoryTheory.InjectiveResolution.descHomotopyZeroSucc.congr_simp | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{I : CategoryTheory.InjectiveResolution Y} {J : CategoryTheory.InjectiveResolution Z}
(f f_1 : I.cocomplex ⟶ J.cocomplex) (e_f : f = f_1) (n : ℕ) (g g_1 : I.cocomplex.X (n + 1) ⟶ J.cocomplex.X n)
(e_g : g = g_1)... | null | true |
Lean.Meta.Tactic.TryThis.Suggestion.style?._default | Lean.Meta.TryThis | Option Lean.Meta.Tactic.TryThis.SuggestionStyle | null | false |
nonneg_of_mul_nonneg_left | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [MulPosStrictMono R], 0 ≤ a * b → 0 < b → 0 ≤ a | null | true |
CliffordAlgebra.ofEven_ι | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (x y : M × R),
(CliffordAlgebra.ofEven Q) (((CliffordAlgebra.even.ι (CliffordAlgebra.EquivEven.Q' Q)).bilin x) y) =
((CliffordAlgebra.ι Q) x.1 + (algebraMap R (CliffordAlgebra Q)) x.2) *
... | null | true |
Module.compHom.toLinearEquiv_apply | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_9} {S : Type u_10} [inst : Semiring R] [inst_1 : Semiring S] (g : R ≃+* S) (a : R),
(Module.compHom.toLinearEquiv g) a = g a | null | true |
Descriptive.Tree.drop | Mathlib.SetTheory.Descriptive.Tree | {A : Type u_1} →
(T : ↥(Descriptive.tree A)) → (n : ℕ) → (x : ↥T) → ↥(Descriptive.Tree.subAt T ↑(Descriptive.Tree.take n x)) | A variant of `List.drop` that takes values in `subAt` | true |
Std.ExtTreeMap.getD_empty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {a : α} {fallback : β},
∅.getD a fallback = fallback | null | true |
TopCat.Presheaf.SheafConditionEqualizerProducts.w | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasProducts C] {X : TopCat}
(F : TopCat.Presheaf C X) {ι : Type v'} (U : ι → TopologicalSpace.Opens ↑X),
CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.SheafConditionEqualizerProducts.res F U)
(TopCat.Presheaf.SheafC... | null | true |
DifferentiableAt.mem_interior_convex_of_surjective_fderiv | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {E : Type u_5} {H : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup H]
[inst_3 : NormedSpace ℝ H] {f : E → H} {x : E},
DifferentiableAt ℝ f x →
∀ {u : Set E},
u ∈ nhds x →
∀ {s : Set H},
Convex ℝ s →
IsClosed s →
... | If a function `f : E → H` is differentiable at `x`, sends a neighbourhood `u` of `x` to a
closed convex set `s` with nonempty interior and has surjective differential at `x`, it must send
`x` to the interior of `s`. | true |
ImportGraph.Lean.Json.instToJsonUInt32_importGraph | ImportGraph.Lean.Json | Lean.ToJson UInt32 | null | true |
Std.DTreeMap.Raw.Equiv.getKeyLTD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
{k fallback : α}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getKeyLTD k fallback = t₂.getKeyLTD k fallback | null | true |
Lean.quoteNameMk | Init.Meta.Defs | Lean.Name → Lean.Term | null | true |
Lean.Meta.Simp.ConfigCtx.congrConsts._inherited_default | Init.MetaTypes | Bool | null | false |
IsSymmSndFDerivWithinAt._proof_4 | Mathlib.Analysis.Calculus.FDeriv.Symmetric | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F | null | false |
IsPrimitiveRoot.powerBasis.congr_simp | Mathlib.NumberTheory.Cyclotomic.Discriminant | ∀ {n n_1 : ℕ} (e_n : n = n_1) [inst : NeZero n] (K : Type u) {L : Type v} [inst_1 : Field K] [inst_2 : CommRing L]
[inst_3 : IsDomain L] [inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] {ζ ζ_1 : L} (e_ζ : ζ = ζ_1)
(hζ : IsPrimitiveRoot ζ n), IsPrimitiveRoot.powerBasis K hζ = IsPrimitiveRoot.powerBasi... | null | true |
Std.HashMap.mem_modify._simp_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : β → β}, (k' ∈ m.modify k f) = (k' ∈ m) | null | false |
AlgebraicGeometry.tilde.modulesSpecToSheafIso | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
(M : ModuleCat ↑R) →
(AlgebraicGeometry.modulesSpecToSheaf.obj (AlgebraicGeometry.tilde M)).obj ≅
AlgebraicGeometry.structurePresheafInModuleCat ↑R ↑M | (Implementation). The image of `tilde` under `modulesSpecToSheaf` is isomorphic to
`structurePresheafInModuleCat`. They are defeq as types but the `Smul` instance are not defeq. | true |
circleIntegrable_sub_zpow_iff | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {c w : ℂ} {R : ℝ} {n : ℤ}, CircleIntegrable (fun z => (z - w) ^ n) c R ↔ R = 0 ∨ 0 ≤ n ∨ w ∉ Metric.sphere c |R| | The function `fun z ↦ (z - w) ^ n`, `n : ℤ`, is circle integrable on the circle with center `c`
and radius `|R|` if and only if `R = 0` or `0 ≤ n`, or `w` does not belong to this circle. | true |
_private.Mathlib.Data.EReal.Inv.0.EReal.abs_mul._simp_1_1 | Mathlib.Data.EReal.Inv | ∀ (x y : ℝ), ↑x * ↑y = ↑(x * y) | null | false |
Ordinal.lt_opow_iff_log_lt' | Mathlib.SetTheory.Ordinal.Exponential | ∀ {b x c : Ordinal.{u_1}}, 1 < b → c ≠ 0 → (x < b ^ c ↔ Ordinal.log b x < c) | `opow b` and `log b` (almost) form a Galois connection.
See `lt_opow_iff_log_lt` for a variant assuming `x ≠ 0` rather than `c ≠ 0`. See also
`lt_opow_of_log_lt` and `lt_log_of_lt_opow`, which are both separate implications under weaker
assumptions. | true |
ModuleCat.normalEpi._proof_1 | Mathlib.Algebra.Category.ModuleCat.Abelian | ∀ {R : Type u_2} [inst : Ring R] {M N : ModuleCat R} (f : M ⟶ N) (hf : CategoryTheory.Epi f),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Cofork.π (ModuleCat.cokernelCocone (ModuleCat.ofHom (ModuleCat.Hom.hom f).ker.subtype)))
((ModuleCat.Hom.hom (ModuleCat.ofHom (ModuleCat.Hom.hom f).ker.su... | null | false |
_private.Mathlib.Tactic.ClickSuggestions.FindPremises.0.Mathlib.Tactic.ClickSuggestions.Entries.casesOn | Mathlib.Tactic.ClickSuggestions.FindPremises | {motive : Mathlib.Tactic.ClickSuggestions.Entries✝ → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.Entries✝) →
((rw :
Array
(Lean.Meta.RefinedDiscrTree.Key ×
Lean.Meta.RefinedDiscrTree.LazyEntry × Mathlib.Tactic.ClickSuggestions.RwLemma)) →
(grw :
Array
... | null | false |
SSet.Subcomplex.PairingCore.ctorIdx | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | {X : SSet} → {A : X.Subcomplex} → A.PairingCore → ℕ | null | false |
_private.Lean.Declaration.0.Lean.instBEqConstantInfo.beq._sparseCasesOn_8 | Lean.Declaration | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.RecursorVal) → motive (Lean.ConstantInfo.recInfo val)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
MonoidAlgebra.mapDomainBialgHomEquiv_symm_apply | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} {G : Type u_5} {H : Type u_6} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : Group G]
[inst_3 : Group H] (f : MonoidAlgebra R G →ₐc[R] MonoidAlgebra R H),
MonoidAlgebra.mapDomainBialgHomEquiv.symm f = MonoidAlgebra.mapDomainOfBialgHom f | null | true |
_private.Mathlib.Algebra.Polynomial.Splits.0.Polynomial.«term_~ᵤ_» | Mathlib.Algebra.Polynomial.Splits | Lean.TrailingParserDescr | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun.0.AbsolutelyContinuousOnInterval.dist_le_of_pairwiseDisjoint_hasSum._proof_1_5 | Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun | ∀ {u : Set (ℝ × ℝ)} ⦃s : Finset ↑u⦄, (Finset.image Subtype.val s).card = (Finset.image Subtype.val s).card | null | false |
Finsupp.DegLex.single_strictAnti | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} [inst : LinearOrder α], StrictAnti fun a => toDegLex fun₀ | a => 1 | null | true |
Lean.Grind.IntModule.toNatModule | Init.Grind.Module.Basic | {M : Type u} → [I : Lean.Grind.IntModule M] → Lean.Grind.NatModule M | null | true |
Mathlib.Tactic.BicategoryLike.Mor₂Iso.isStructural._sunfold | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Bool | null | false |
monoidHomOfForallMemZpowers._proof_3 | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {G : Type u_2} {G' : Type u_1} [inst : Group G] [inst_1 : Group G'] {g : G} (hg : ∀ (x : G), x ∈ Subgroup.zpowers g)
{g' : G'},
orderOf g' ∣ orderOf g → ∀ (x y : G), g' ^ Classical.choose ⋯ = g' ^ Classical.choose ⋯ * g' ^ Classical.choose ⋯ | null | false |
ListSlice.size_eq_length_toList | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.size xs = (Std.Slice.toList xs).length | null | true |
CompactlySupportedContinuousMap.continuousMapEquiv._proof_3 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
[inst_3 : CompactSpace α],
Function.RightInverse (fun f => ↑f) fun f => { toFun := ⇑f, continuous_toFun := ⋯, hasCompactSupport' := ⋯ } | null | false |
List.ne_and_not_mem_of_not_mem_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a y : α} {l : List α}, a ∉ y :: l → a ≠ y ∧ a ∉ l | null | true |
_private.Mathlib.Geometry.Euclidean.Sphere.Tangent.0.EuclideanGeometry.Sphere.tangentsFrom_eq_singleton_orthRadius_of_mem._simp_1_3 | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
_private.Mathlib.LinearAlgebra.Finsupp.Supported.0.Finsupp.lmapDomain_disjoint_ker._simp_1_3 | Mathlib.LinearAlgebra.Finsupp.Supported | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set α} (p : α →₀ M), (p ∈ Finsupp.supported M R s) = (↑p.support ⊆ s) | null | false |
Cardinal.mk_Ioi_real | Mathlib.Analysis.Real.Cardinality | ∀ (a : ℝ), Cardinal.mk ↑(Set.Ioi a) = Cardinal.continuum | The cardinality of the interval $(a, ∞)$. | true |
ContinuousAlternatingMap.instSeminormedAddCommGroup._proof_3 | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {ι : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] (x y : E [⋀^ι]→L[𝕜] F), dist x y = ‖-x + y‖ | null | false |
CategoryTheory.GrothendieckTopology.MayerVietorisSquare.mk_of_isPullback._proof_1 | Mathlib.CategoryTheory.Sites.MayerVietorisSquare | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
(sq : CategoryTheory.Square C) [CategoryTheory.Mono sq.f₂₄] [CategoryTheory.Mono sq.f₃₄],
sq.IsPullback →
CategoryTheory.Sieve.ofTwoArrows sq.f₂₄ sq.f₃₄ ∈ J sq.X₄ →
∀ (F : CategoryTheory.Sheaf J (Typ... | null | false |
MonoidWithZeroHom.instLinearOrderedCommGroupWithZeroMrange._proof_11 | Mathlib.RingTheory.Valuation.Archimedean | ∀ {F : Type u_2} {Γ₀ : Type u_1} [inst : Field F] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : F →*₀ Γ₀) (n : ℕ)
(a : ↥(MonoidHom.mrange v)), a ^ ↑n.succ = a ^ ↑n * a | null | false |
Set.compl_inv | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Inv α] {s : Set α}, sᶜ⁻¹ = s⁻¹ᶜ | null | true |
CommRingCat.FilteredColimits.forget_preservesFilteredColimits | Mathlib.Algebra.Category.Ring.FilteredColimits | CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget CommRingCat) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.