name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Batteries.CodeAction.startTacticStub | Batteries.CodeAction.Misc | Lean.CodeAction.HoleCodeAction | Invoking hole code action "Start a tactic proof" will fill in a hole with `by done`. | true |
PrimeMultiset.prod_dvd_prod | Mathlib.Data.PNat.Factors | ∀ {u v : PrimeMultiset}, u ≤ v → u.prod ∣ v.prod | **Alias** of the reverse direction of `PrimeMultiset.prod_dvd_iff`. | true |
Lean.Meta.Sym.DSimp.Result.ctorIdx | Lean.Meta.Sym.DSimp.DSimpM | Lean.Meta.Sym.DSimp.Result → ℕ | null | false |
AlgebraicGeometry.ExistsHomHomCompEqCompAux._sizeOf_inst | Mathlib.AlgebraicGeometry.AffineTransitionLimit | {I : Type u} →
{inst : CategoryTheory.Category.{u, u} I} →
{S X : AlgebraicGeometry.Scheme} →
(D : CategoryTheory.Functor I AlgebraicGeometry.Scheme) →
(t : D ⟶ (CategoryTheory.Functor.const I).obj S) →
(f : X ⟶ S) → [SizeOf I] → SizeOf (AlgebraicGeometry.ExistsHomHomCompEqCompAux D t f) | null | false |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Induction.0.Lean.Elab.PartialFixpoint.deriveInduction.match_7 | Lean.Elab.PreDefinition.PartialFixpoint.Induction | (motive : Array Lean.Expr × Array (Array Bool) → Sort u_1) →
(x : Array Lean.Expr × Array (Array Bool)) →
((hTypes : Array Lean.Expr) → (masks : Array (Array Bool)) → motive (hTypes, masks)) → motive x | null | false |
Lean.Lsp.DocumentColorParams.workDoneToken?._inherited_default | Lean.Data.Lsp.LanguageFeatures | Option Lean.Lsp.ProgressToken | null | false |
_private.Std.Data.DHashMap.Internal.HashesTo.0.Std.DHashMap.Internal.List.HashesTo.containsKey_eq_false._simp_1_1 | Std.Data.DHashMap.Internal.HashesTo | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α},
(Std.Internal.List.containsKey a l = true) = ∃ p ∈ l, (p.fst == a) = true | null | false |
Additive.subtractionMonoid._proof_1 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (x : Additive α), - -x = x | null | false |
MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_sum_measure | Mathlib.MeasureTheory.Measure.Basic | ∀ {α : Type u_1} {ι : Type u_3} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {s : Finset ι} {t : ι → Set α},
(∀ i ∈ s, MeasureTheory.NullMeasurableSet (t i) μ) →
μ Set.univ < ∑ i ∈ s, μ (t i) → ∃ i ∈ s, ∃ j ∈ s, ∃ (_ : i ≠ j), (t i ∩ t j).Nonempty | Pigeonhole principle for measure spaces: if `s` is a `Finset` and
`∑ i ∈ s, μ (t i) > μ univ`, then one of the intersections `t i ∩ t j` is not empty. | true |
CategoryTheory.Limits.botSquareIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{Y₃ Y₂ Y₁ X₃ : C} →
{g₂ : Y₃ ⟶ Y₂} →
{g₁ : Y₂ ⟶ Y₁} →
{i₃ : Y₃ ⟶ X₃} →
{t₁ : CategoryTheory.Limits.PushoutCocone g₂ i₃} →
{i₂ : Y₂ ⟶ t₁.pt} →
(t₂ : CategoryTheory.Limits.PushoutCocone g₁ i₂... | Given
```
Y₃ - i₃ -> X₃
| |
g₂ f₂
∨ ∨
Y₂ - i₂ -> X₂
| |
g₁ f₁
∨ ∨
Y₁ - i₁ -> X₁
```
The bottom square is a pushout if the top square and the big square are.
| true |
Std.TreeSet.Raw.insert | Std.Data.TreeSet.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet.Raw α cmp → α → Std.TreeSet.Raw α cmp | Creates a new empty tree set. It is also possible and recommended to
use the empty collection notations `∅` and `{}` to create an empty tree set. `simp` replaces
`empty` with `∅`.
| true |
List.min?_eq_some_iff_subtype | Init.Data.List.MinMax | ∀ {α : Type u_1} {a : α} [inst : Min α] [inst_1 : LE α] {xs : List α} [inst_2 : Std.MinEqOr α]
[Std.IsLinearOrder { x // x ∈ xs }] [Std.LawfulOrderMin { x // x ∈ xs }], xs.min? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, a ≤ b | null | true |
Finset.disjSups_empty_left | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] [inst_2 : OrderBot α]
[inst_3 : DecidableRel Disjoint] {t : Finset α}, ∅.disjSups t = ∅ | null | true |
CategoryTheory.Functor.instLaxMonoidalMonMapAddMon._proof_6 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.BraidedCategory C]
[inst_5 : CategoryThe... | null | false |
_private.Mathlib.Order.Filter.AtTopBot.ModEq.0.Nat.frequently_even._simp_1_1 | Mathlib.Order.Filter.AtTopBot.ModEq | ∀ {n : ℕ}, Even n = (n % 2 = 0) | null | false |
Mathlib.Tactic.Echelon.BareissData.mk._flat_ctor | Mathlib.Tactic.Echelon.Core | {V : Type} → Array (Array V) → Array (Array V) → Array (ℕ × ℕ) → Array ℕ → Mathlib.Tactic.Echelon.BareissData V | null | false |
Decidable.rec | Init.Prelude | {p : Prop} →
{motive : Decidable p → Sort u} →
((decide : Bool) →
(reflects_decide : decide.Reflects p) → motive { decide := decide, reflects_decide := reflects_decide }) →
(t : Decidable p) → motive t | null | false |
NNReal.coe_multiset_prod | Mathlib.Basic.NNReal.Basic | ∀ (s : Multiset NNReal), ↑s.prod = (Multiset.map NNReal.toReal s).prod | null | true |
SModEq.bot | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
x ≡ y [SMOD ⊥] ↔ x = y | null | true |
imp_congr_left | Init.Core | ∀ {a b c : Prop}, (a ↔ b) → (a → c ↔ b → c) | null | true |
ContinuousOn.div₀ | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀] [ContinuousInv₀ G₀]
[ContinuousMul G₀] {f g : α → G₀} [inst_4 : TopologicalSpace α] {s : Set α},
ContinuousOn f s → ContinuousOn g s → (∀ x ∈ s, g x ≠ 0) → ContinuousOn (fun x => f x / g x) s | null | true |
CategoryTheory.Presieve.bind | Mathlib.CategoryTheory.Sites.Sieves.Presieve | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(S : CategoryTheory.Presieve X) →
(⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y) → CategoryTheory.Presieve X | Given a presieve `S` on `X`, and presieve `R` on `Y` for each
`f : Y ⟶ X` in `S`, produce a presieve on `X`:
`{ g ≫ f | (f : Y ⟶ X) ∈ S, (g : Z ⟶ Y) ∈ R f }`.
| true |
_private.Mathlib.NumberTheory.ModularForms.RamanujanFormula.0.Derivative.normalizedDerivOfComplex_D2._simp_1_2 | Mathlib.NumberTheory.ModularForms.RamanujanFormula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
HasSum.tsum_fiberwise | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [IsUniformAddGroup α]
[CompleteSpace α] [T2Space α] {f : β → α} {a : α},
HasSum f a → ∀ (g : β → γ), HasSum (fun c => ∑' (b : ↑(g ⁻¹' {c})), f ↑b) a | null | true |
_private.Mathlib.Algebra.Star.LinearMap.0.LinearMap.IntrinsicStar.isSelfAdjoint_iff_map_star._simp_1_3 | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u} [inst : InvolutiveStar R] {r s : R}, (star r = s) = (star s = r) | null | false |
StandardSubspace.mulI._proof_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] (S : StandardSubspace H),
S.toClosedSubmodule.mulI ⊓ S.toClosedSubmodule.mulI.mulI = ⊥ | null | false |
differentiableAt_comp_const_sub | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {a b : 𝕜},
DifferentiableAt 𝕜 (fun x => f (b - x)) a ↔ DifferentiableAt 𝕜 f (b - a) | null | true |
MeasureTheory.Measure.IsNegInvariant.recOn | Mathlib.MeasureTheory.Group.Measure | {G : Type u_1} →
[inst : MeasurableSpace G] →
[inst_1 : Neg G] →
{μ : MeasureTheory.Measure G} →
{motive : μ.IsNegInvariant → Sort u} →
(t : μ.IsNegInvariant) → ((neg_eq_self : μ.neg = μ) → motive ⋯) → motive t | null | false |
ContinuousMap.Homotopy.comp._proof_2 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_3} {Y : Type u_2} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Y, Z)} (G : g₀.Homotopy g₁) (F : f₀.Homotopy f₁) (x : X),
G ((0, x).1, F (0, x)) = (g₀.comp f₀) x | null | false |
_private.Mathlib.Tactic.ITauto.0.Mathlib.Tactic.ITauto.search._sparseCasesOn_16 | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.IProp → Sort u} →
(t : Mathlib.Tactic.ITauto.IProp) →
((a a_1 : Mathlib.Tactic.ITauto.IProp) → motive (a.or a_1)) → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeapImp.Heap.merge.match_1 | Batteries.Data.PairingHeap | {α : Type u_1} →
(motive : Batteries.PairingHeapImp.Heap α → Batteries.PairingHeapImp.Heap α → Sort u_2) →
(x x_1 : Batteries.PairingHeapImp.Heap α) →
(Unit → motive Batteries.PairingHeapImp.Heap.nil Batteries.PairingHeapImp.Heap.nil) →
((a₂ : α) →
(c₂ sibling : Batteries.PairingHeapImp.... | null | false |
Nat.bodd_one | Mathlib.Data.Nat.Bits | Nat.bodd 1 = true | null | true |
Subgroup.inclusion_inj | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (h : H ≤ K) {x y : ↥H},
(Subgroup.inclusion h) x = (Subgroup.inclusion h) y ↔ x = y | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Affine.0.AlgebraicGeometry.isAffine_of_isAffineOpen_basicOpen._simp_1_2 | Mathlib.AlgebraicGeometry.Morphisms.Affine | ∀ {R : CommRingCat} (f : ↑R),
PrimeSpectrum.basicOpen f =
(AlgebraicGeometry.Spec R).basicOpen
((CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.ΓSpecIso R).inv) f) | null | false |
Lean.Meta.CaseArraySizesSubgoal | Lean.Meta.Match.CaseArraySizes | Type | null | true |
_private.Std.Internal.Order.PreservesSup.0.Lean.Order.prod_eq_of_pprod_eq | Std.Internal.Order.PreservesSup | ∀ {α : Type u} {β : Type v} {p q : α × β}, ⟨p.1, p.2⟩ = ⟨q.1, q.2⟩ → p = q | Two pairs with equal components are equal. | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.needsExplicit._sparseCasesOn_4 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) →
motive Lean.BinderInfo.implicit →
motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 10 t.ctorIdx → motive t) → motive t | null | false |
RootPairing.restrictScalars'._proof_5 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_5} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_2)
[inst_5 : Field K] [inst_6 : Algebra K L] [inst_7 : Module K M] [inst_8 : Module K N] [inst_9 : IsSc... | null | false |
QuotientAddGroup.lift.eq_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_4} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
(φ : G →+ M) (HN : N ≤ φ.ker), QuotientAddGroup.lift N φ HN = (QuotientAddGroup.con N).lift φ ⋯ | null | true |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_2 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : (AlgebraicGeometry.Spec R).Modules) (f : (↑R)ᵒᵖ),
IsLocalizedModule.Away (Opposite.unop f)
(ModuleCat.Hom.hom
(AlgebraicGeometry.tilde.toOpen ((AlgebraicGeometry.modulesSpecToSheaf.obj M).obj.obj (Opposite.op ⊤))
(PrimeSpectrum.basicOpen (Opposite.unop f)))) | null | false |
Std.Http.Chunk.instDecidableEqExtensionValue | Std.Http.Data.Chunk | DecidableEq Std.Http.Chunk.ExtensionValue | null | true |
AddSubmonoid.subPairs.eq_1 | Mathlib.GroupTheory.MonoidLocalization.DivPairs | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (f : ⊤.LocalizationMap G)
(s : AddSubmonoid G), AddSubmonoid.subPairs f s = AddSubmonoid.comap (subAddMonoidHom.comp ((↑f).prodMap ↑f)) s | null | true |
Lean.Server.CodeActionResolveData.noConfusion | Lean.Server.CodeActions.Basic | {P : Sort u} →
{t t' : Lean.Server.CodeActionResolveData} → t = t' → Lean.Server.CodeActionResolveData.noConfusionType P t t' | null | false |
List.rdrop.eq_1 | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (l : List α) (n : ℕ), l.rdrop n = List.take (l.length - n) l | null | true |
_private.Aesop.Forward.State.0.Aesop.VariableMap.modifyM.match_1 | Aesop.Forward.State | {α : Type u_1} →
(motive : Aesop.InstMap × α → Sort u_2) →
(x : Aesop.InstMap × α) → ((m : Aesop.InstMap) → (a : α) → motive (m, a)) → motive x | null | false |
Lean.Lsp.DocumentSymbolAux.children?._default | Lean.Data.Lsp.LanguageFeatures | {Self : Type} → Option (Array Self) | null | false |
UInt8.ofNat_eq_iff_mod_eq_toNat | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt8), UInt8.ofNat a = b ↔ a % 2 ^ 8 = b.toNat | null | true |
_private.Init.Data.List.Sort.Impl.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [... | null | true |
CategoryTheory.MorphismProperty.map_mem_map | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(P : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y),
P f → P.map F (F.map f) | null | true |
CategoryTheory.PreZeroHypercover.Hom._sizeOf_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{S : C} →
{E : CategoryTheory.PreZeroHypercover S} → {F : CategoryTheory.PreZeroHypercover S} → [SizeOf C] → E.Hom F → ℕ | null | false |
_private.Mathlib.Order.Monotone.Basic.0.not_monotone_not_antitone_iff_exists_lt_lt._simp_1_1 | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β},
(¬Monotone f ∧ ¬Antitone f) = ∃ a b c, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) | null | false |
TensorialAt.mkHom._proof_6 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
Matroid.eRk_union_closure_right_eq | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X Y : Set α), M.eRk (X ∪ M.closure Y) = M.eRk (X ∪ Y) | null | true |
PolynomialLaw.mk | Mathlib.RingTheory.PolynomialLaw.Basic | {R : Type u} →
[inst : CommSemiring R] →
{M : Type u_1} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Type u_2} →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
(toFun' :
(S : Type u) →
... | null | true |
AlgebraicGeometry.StructureSheaf.const_algebraMap | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R A : Type u} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (f : R)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (hu : U ≤ PrimeSpectrum.basicOpen f),
AlgebraicGeometry.StructureSheaf.const ((algebraMap R A) f) f U hu = 1 | null | true |
Lean.Elab.Tactic.evalSym | Lean.Elab.Tactic.Grind.Main | Lean.Elab.Tactic.Tactic | null | true |
CategoryTheory.enrichedNatTransYonedaTypeIsoYonedaNatTrans | Mathlib.CategoryTheory.Enriched.Basic | {C : Type v} →
[inst : CategoryTheory.EnrichedCategory (Type v) C] →
{D : Type v} →
[inst_1 : CategoryTheory.EnrichedCategory (Type v) D] →
(F G : CategoryTheory.EnrichedFunctor (Type v) C D) →
CategoryTheory.enrichedNatTransYoneda F G ≅
CategoryTheory.yoneda.obj
... | We verify that the presheaf representing natural transformations
between `Type v`-enriched functors is actually represented by
the usual type of natural transformations!
| true |
_private.Init.Data.Array.Lemmas.0.Array.getElem?_size._simp_1_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), (n < n) = False | null | false |
Convex.lift | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : Module 𝕜 E] (R : Type u_5) [inst_5 : Semiring R] [inst_6 : PartialOrder R]
[inst_7 : Module R E] [inst_8 : Module R 𝕜] [IsScalarTower R 𝕜 E] [SMulPosMono R 𝕜] {s : Set E},
... | Lift the convexity of a set up through a scalar tower. | true |
Std.Time.instReprOffsetO.repr | Std.Time.Format.Modifier | Std.Time.OffsetO → ℕ → Std.Format | null | true |
Filter.EventuallyEq.of_eventually_mem_of_forall_separating_preimage | Mathlib.Order.Filter.CountableSeparatingOn | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f g : α → β} (p : Set β → Prop) {s : Set β}
[HasCountableSeparatingOn β p s],
(∀ᶠ (x : α) in l, f x ∈ s) → (∀ᶠ (x : α) in l, g x ∈ s) → (∀ (U : Set β), p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U) → f =ᶠ[l] g | null | true |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.simpJpCases?.visitJmp?.match_5 | Lean.Compiler.LCNF.Simp.JpCases | (motive : Option Lean.Compiler.LCNF.Simp.CtorInfo → Sort u_1) →
(__x : Option Lean.Compiler.LCNF.Simp.CtorInfo) →
((ctorInfo : Lean.Compiler.LCNF.Simp.CtorInfo) → motive (some ctorInfo)) →
((x : Option Lean.Compiler.LCNF.Simp.CtorInfo) → motive x) → motive __x | null | false |
_private.Mathlib.RingTheory.WittVector.FrobeniusFractionField.0.WittVector.frobeniusRotationCoeff.match_1.eq_2 | Mathlib.RingTheory.WittVector.FrobeniusFractionField | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | null | true |
AmpleSet.vadd_iff | Mathlib.Analysis.Convex.AmpleSet | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [ContinuousAdd E]
{s : Set E} {y : E}, AmpleSet (y +ᵥ s) ↔ AmpleSet s | A set is ample iff its affine translation is. | true |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.IsOpen.exists_iUnion_isClosed._simp_1_4 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Set.Ioc.coe_sup._simp_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeSup α] {a b : α} {x y : ↑(Set.Ioc b a)}, ↑x ⊔ ↑y = ↑(x ⊔ y) | null | false |
Std.LawfulBCmp.rec | Batteries.Classes.Order | {α : Type u_1} →
[inst : LE α] →
[inst_1 : LT α] →
[inst_2 : BEq α] →
{cmp : α → α → Ordering} →
{motive : Std.LawfulBCmp cmp → Sort u} →
([toTransCmp : Std.TransCmp cmp] →
[toLawfulBEqCmp : Std.LawfulBEqCmp cmp] →
(eq_lt_iff_lt : ∀ {x y : α}, ... | null | false |
_private.Init.Data.String.PosRaw.0.String.Pos.Raw.offsetBy_unoffsetBy_of_le._simp_1_1 | Init.Data.String.PosRaw | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.matchExpr._regBuiltin.Lean.Parser.Term.matchExpr_1 | Lean.Parser.Term | IO Unit | null | false |
Std.Time.WallTime.instHSubOffset_2 | Std.Time.DateTime.WallTime | HSub Std.Time.WallTime Std.Time.Hour.Offset Std.Time.WallTime | null | true |
Lean.Meta.Grind.Arith.CommRing.State.reportedMaxDegreeIssue._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Bool | null | false |
Function.instIsStrictWeakOrderOnFun | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (r : β → β → Prop) (f : α → β) [IsStrictWeakOrder β r],
IsStrictWeakOrder α (Function.onFun r f) | null | true |
CategoryTheory.Arrow.LeftHomotopy.compLeftId._proof_1 | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {u v : CategoryTheory.Arrow V} (g : u ⟶ v),
CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.id v) = g | null | false |
CategoryTheory.Functor.mapConePostcomposeEquivalenceFunctor._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
(H : CategoryTheory.Functor C D) {F G : CategoryTheory.Functor J C} {α : F ≅ G} {c : CategoryTheory.Limits.Cone F}
(j : J),
... | null | false |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.meromorphicOrderAt_canonicalFactor._proof_1_1 | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {R : ℝ} {w : ℂ}, ‖w‖ < R → ¬R = ‖w‖ | null | false |
Filter.EventuallyEq.trans_le | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f g h : α → β}, f =ᶠ[l] g → g ≤ᶠ[l] h → f ≤ᶠ[l] h | null | true |
GromovHausdorff.premetricOptimalGHDist._proof_1 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ (X : Type u_1) (Y : Type u_2) [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
[inst_3 : MetricSpace Y] [inst_4 : CompactSpace Y] [inst_5 : Nonempty Y] (x y : X ⊕ Y),
↑(NNReal.mk ((fun p q => (GromovHausdorff.optimalGHDist✝ X Y) (p, q)) x y) ⋯) =
ENNReal.ofReal ((GromovHausdorff.optimalG... | null | false |
CategoryTheory.MorphismProperty.LeftFraction.Localization.instIsIsoQinv | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C}
[inst_1 : W.HasLeftCalculusOfFractions] {X Y : C} (s : X ⟶ Y) (hs : W s),
CategoryTheory.IsIso (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv s hs) | null | true |
_private.Mathlib.Algebra.Ring.Subsemiring.Basic.0.RingHom.rangeSRestrict_surjective.match_1_3 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S)
(motive : ↥f.rangeS → Prop) (x : ↥f.rangeS), (∀ (val : S) (hy : val ∈ f.rangeS), motive ⟨val, hy⟩) → motive x | null | false |
RingHom.inverse._proof_6 | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (g : S → R)
(h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f), (↑((↑f).inverse g h₁ h₂)).toFun 0 = 0 | null | false |
IO.FS.Mode.append | Init.System.IO | IO.FS.Mode | The file should be opened for writing.
If the file does not already exist, it is created. If the file already exists, it is opened, and
the read/write cursor is positioned at the end of the file.
* `open` flags: `O_WRONLY | O_CREAT | O_APPEND`
* `fdopen` mode: `a`
| true |
Int.sub_one_lt_of_le | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → a - 1 < b | null | true |
Lean.Elab.DefView._sizeOf_inst | Lean.Elab.DefView | SizeOf Lean.Elab.DefView | null | false |
Lean.Syntax.node2 | Init.Prelude | Lean.SourceInfo → Lean.SyntaxNodeKind → Lean.Syntax → Lean.Syntax → Lean.Syntax | Create syntax node with 2 children | true |
LowerSet.instOne | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} → [CommGroup α] → [inst : Preorder α] → One (LowerSet α) | null | true |
Std.DHashMap.Raw.Const.find?_toList_eq_none_iff_not_mem._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {k : α}, (List.find? (fun x => x.1 == k) (Std.DHashMap.Raw.Const.toList m) = none) = (k ∉ m) | null | false |
CategoryTheory.Adjunction.IsTriangulated.mk'' | Mathlib.CategoryTheory.Triangulated.Adjunction | ∀ {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] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.Limits.HasZeroObject D] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : CategoryTheory.Preadditive D] [inst_6 : ... | Constructor for `Adjunction.IsTriangulated`.
| true |
ZMod.prodEquivPi | Mathlib.Data.ZMod.QuotientRing | {ι : Type u_2} →
[inst : Fintype ι] →
(a : ι → ℕ) → Pairwise (Function.onFun Nat.Coprime a) → ZMod (∏ i, a i) ≃+* ((i : ι) → ZMod (a i)) | The **Chinese remainder theorem**, elementary version for `ZMod`. See also
`Mathlib/Data/ZMod/Basic.lean` for versions involving only two numbers. | true |
Complex.cos | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ | The complex cosine function, defined via `exp` | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Combination.0.Finset.sum_affineCombinationLineMapWeights._simp_1_4 | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, a * f i = a * ∑ i ∈ s, f i | null | false |
Filter.bliminf_not_inf | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteDistribLattice α] {f : Filter β} {p : β → Prop} {u : β → α},
(Filter.bliminf u f fun x => ¬p x) ⊓ Filter.bliminf u f p = Filter.liminf u f | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.DerivIntegrable.0.MonotoneOn.exists_tendsto_deriv_liminf_lintegral_enorm_le._proof_1_4 | Mathlib.MeasureTheory.Integral.IntervalIntegral.DerivIntegrable | ∀ {f : ℝ → ℝ} {a b : ℝ},
a ≤ b →
ENNReal.ofReal ((fun x => f (max a (min x b))) b - (fun x => f (max a (min x b))) a) = ENNReal.ofReal (f b - f a) | null | false |
Std.DHashMap.Raw.get!_diff | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α],
m₁.WF → m₂.WF → ∀ {k : α} [inst_3 : Inhabited (β k)], (m₁ \ m₂).get! k = if k ∈ m₂ then default else m₁.get! k | null | true |
CliffordAlgebra.foldr'._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Fold | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticForm R M), SMulCommClass R R (CliffordAlgebra Q × N) | null | false |
Finsupp.embDomain.addMonoidHom._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_3} {F : Type u_1} {M : Type u_2} [inst : AddZeroClass M] (f : ι ↪ F), Finsupp.embDomain f 0 = 0 | null | false |
RingQuot.ringQuot_ext' | Mathlib.Algebra.RingQuot | ∀ (S : Type uS) [inst : CommSemiring S] {A : Type uA} [inst_1 : Semiring A] [inst_2 : Algebra S A] {B : Type u₄}
[inst_3 : Semiring B] [inst_4 : Algebra S B] {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B),
f.comp (RingQuot.mkAlgHom S s) = g.comp (RingQuot.mkAlgHom S s) → f = g | null | true |
_private.Mathlib.Lean.MessageData.ForExprs.0.Lean.MessageData.firstExpr?.match_3 | Mathlib.Lean.MessageData.ForExprs | (motive : Lean.PPContext × Lean.Expr → Sort u_1) →
(x : Lean.PPContext × Lean.Expr) → ((ppCtx : Lean.PPContext) → (e : Lean.Expr) → motive (ppCtx, e)) → motive x | null | false |
Mathlib.Meta.FunProp.instBEqTheoremForm | Mathlib.Tactic.FunProp.Theorems | BEq Mathlib.Meta.FunProp.TheoremForm | null | true |
String.empty_ne_singleton | Init.Data.String.Lemmas.Basic | ∀ {c : Char}, "" ≠ String.singleton c | null | true |
Ideal.absNorm_dvd_absNorm_of_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDedekindDomain S] [inst_2 : Infinite S] {I J : Ideal S},
J ≤ I → Ideal.absNorm I ∣ Ideal.absNorm J | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.