name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Multiset.Nodup.ofPowerset | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {s : Multiset α}, s.powerset.Nodup → s.Nodup | **Alias** of the forward direction of `Multiset.nodup_powerset`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Maps.0.SimpleGraph.map_map._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_3} {W : Type u_2} {X : Type u_1} (G : SimpleGraph V) (f : V → W) (g : W → X) (x x_1 : X),
(SimpleGraph.map g (SimpleGraph.map f G)).Adj x x_1 ↔ (SimpleGraph.map (g ∘ f) G).Adj x x_1 | null | false |
Nat.zero_sub_one | Init.Data.Nat.Basic | 0 - 1 = 0 | null | true |
Mathlib.Tactic.GCongr.GCongrKey.arity | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrKey → ℕ | The number of arguments that `head` is applied to.
For example, `a + b ≤ a + c` has `arity := 6`, because `HAdd.hAdd` has 6 arguments. | true |
cfc_le_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [ContinuousSqrt R]
[StarOrderedRing R] [inst_8 : TopologicalSpace A] [inst_9 : Ring A] [inst_10 : StarRing A] [inst_1... | null | true |
Nat.prime_of_pow_sub_one_prime | Mathlib.NumberTheory.Fermat | ∀ {a n : ℕ}, n ≠ 1 → Nat.Prime (a ^ n - 1) → a = 2 ∧ Nat.Prime n | Prime `a ^ n - 1` implies `a = 2` and prime `n`. | true |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.InSubtree.mem_of_zero._proof_1_6 | Batteries.Data.BinaryHeap.WF | ∀ (n : ℕ), n + 1 = 2 * (n / 2) + 2 → ¬n / 2 < n + 1 → False | null | false |
List.Vector.map_map | Mathlib.Data.Vector.MapLemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {n : ℕ} (xs : List.Vector α n) (f₁ : β → γ) (f₂ : α → β),
List.Vector.map f₁ (List.Vector.map f₂ xs) = List.Vector.map (fun x => f₁ (f₂ x)) xs | null | true |
_private.Lean.Parser.Basic.0.Lean.Parser.checkLinebreakBefore._regBuiltin.Lean.Parser.checkLinebreakBefore.docString_1 | Lean.Parser.Basic | IO Unit | null | false |
Lean.Lsp.instLTRange | Lean.Data.Lsp.BasicAux | LT Lean.Lsp.Range | null | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_12 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt64), a / 1 = a | null | false |
_private.Mathlib.Data.Rat.Floor.0.Rat.evalIntFloor._proof_2 | Mathlib.Data.Rat.Floor | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.blastDivSubtractShift._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (n d : aig.RefVec w) (wn : ℕ)
(q r : aig.RefVec w)
(this :
aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.blastShiftConcat aig
{ lhs := r, bit := n.getD (wn - 1) (aig.mkConstCached false)... | null | false |
Algebra.PreSubmersivePresentation.naive_toPresentation | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {ι : Type w} {σ : Type t} [inst : CommRing R] {v : ι → MvPolynomial σ R} (a : ι → σ)
(ha : Function.Injective a)
(s : optParam (MvPolynomial σ R ⧸ Ideal.span (Set.range v) → MvPolynomial σ R) (Function.surjInv ⋯))
(hs :
autoParam
(∀ (x : MvPolynomial σ R ⧸ Ideal.span (Set.range v)), (Idea... | null | true |
ContinuousAlgEquivClass.toHomeomorphClass | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} {inst : CommSemiring R}
{inst_1 : Semiring A} {inst_2 : TopologicalSpace A} {inst_3 : Semiring B} {inst_4 : TopologicalSpace B}
{inst_5 : Algebra R A} {inst_6 : Algebra R B} {inst_7 : EquivLike F A B} [self : ContinuousAl... | null | true |
List.unzip | Init.Data.List.Basic | {α : Type u} → {β : Type v} → List (α × β) → List α × List β | Separates a list of pairs into two lists that contain the respective first and second components.
`O(|l|)`.
Examples:
* `[("Monday", 1), ("Tuesday", 2)].unzip = (["Monday", "Tuesday"], [1, 2])`
* `[(x₁, y₁), (x₂, y₂), (x₃, y₃)].unzip = ([x₁, x₂, x₃], [y₁, y₂, y₃])`
* `([] : List (Nat × String)).unzip = (([], []) : Li... | true |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.sub_scalar_sq_eq_discr._simp_1_7 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
LSeries.term_add_apply | Mathlib.NumberTheory.LSeries.Linearity | ∀ (f g : ℕ → ℂ) (s : ℂ) (n : ℕ), LSeries.term (f + g) s n = LSeries.term f s n + LSeries.term g s n | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_26 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (tail : List α) {i : ℕ} (s : ℕ) (h : i - 1 + 1 ≤ (List.filter p tail).length),
(List.findIdxs p tail (s + 1))[i - 1] - (s + 1) < tail.length | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.smulOverflow_assoc._simp_1_2 | Init.Data.BitVec.Lemmas | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
IsMinFilter.max | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] {f g : α → β} {a : α} {l : Filter α},
IsMinFilter f l a → IsMinFilter g l a → IsMinFilter (fun x => max (f x) (g x)) l a | null | true |
Finset.Nonempty.snd | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, (s ×ˢ t).Nonempty → t.Nonempty | null | true |
IsPreconnected.eq_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f g : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Field 𝕜] [ContinuousInv₀ 𝕜] [ContinuousMul 𝕜],
IsPreconnected S →
ContinuousOn f S →
ContinuousOn g S →
Set.EqOn (f ^ 2) (g ^ 2) S → (∀ {x : α}, x ∈ S → ... | If `f, g` are functions `α → 𝕜`, both continuous on a preconnected set `S`, with
`f ^ 2 = g ^ 2` on `S`, and `g z ≠ 0` all `z ∈ S`, then as soon as `f = g` holds at
one point of `S` it holds for all points. | true |
_private.Lean.DocString.Markdown.0.Lean.Doc.splitNewlines | Lean.DocString.Markdown | String → Array String | Splits a string into an array of lines on `'\n'`, retaining empty trailing/leading lines (so
`"a\nb\n"` yields `#["a", "b", ""]`). Used to convert code blocks into the line-array representation
used by the rest of the renderer.
| true |
Module.Basis.eval_ker | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_1}
(b : Module.Basis ι R M), (Module.Dual.eval R M).ker = ⊥ | null | true |
_private.Mathlib.CategoryTheory.Limits.ConstructLimitMap.0.CategoryTheory.ConstructLimitMap.left | Mathlib.CategoryTheory.Limits.ConstructLimitMap | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{I : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} I] →
{D : CategoryTheory.Functor I C} →
(c : CategoryTheory.Limits.Cone D) → CategoryTheory.Functor I (CategoryTheory.Under c.pt) | null | true |
List.mem_of_mem_tail | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l.tail → a ∈ l | null | true |
_private.Lean.Elab.PreDefinition.WF.Preprocess.0.Lean.Elab.WF.anyLetValueIsWfParam._f | Lean.Elab.PreDefinition.WF.Preprocess | (e : Lean.Expr) → Lean.Expr.below e → Bool | null | false |
Aesop.LIFOQueue.popGoal | Aesop.Search.Queue | Aesop.LIFOQueue → Option Aesop.GoalRef × Aesop.LIFOQueue | null | true |
ContinuousOn.image_Iio_of_strictAntiOn | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a : α} {f : α → δ},
ContinuousOn f (Set.Iic a) →
StrictAntiOn f (Set.Iic a) → Filter.Tend... | null | true |
CategoryTheory.Functor.sheafPushforwardContinuousIso_inv | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F F' : CategoryTheory.Functor C D} (e : F ≅ F') (A : Type u) [inst_2 : CategoryTheory.Category.{t, u} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [i... | null | true |
UniformEquiv.finTwoArrow | Mathlib.Topology.UniformSpace.Equiv | (α : Type u_4) → [inst : UniformSpace α] → (Fin 2 → α) ≃ᵤ α × α | Uniform isomorphism between `α² = Fin 2 → α` and `α × α`. | true |
RootPairingCat.category._proof_1 | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : RootPairingCat R} (f : X.pairing.Hom Y.pairing),
f.comp (RootPairing.Hom.id X.pairing) = f | null | false |
CategoryTheory.OrthogonalReflection.isLocal_isLocal_reflection | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (Z : C)
[inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_3 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct Categ... | null | true |
ForInStep.value_yield | Init.Control.Basic | ∀ {β : Type u_1} (b : β), (ForInStep.yield b).value = b | null | true |
WithZero.instCommMonoidWithZero._proof_3 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : CommMonoid α] (a : WithZero α), a * 0 = 0 | null | false |
inf_nhds_atBot | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : Preorder α] [NoBotOrder α] [inst_2 : TopologicalSpace α] [ClosedIicTopology α] (a : α),
nhds a ⊓ Filter.atBot = ⊥ | **Alias** of `nhds_inf_atBot`. | true |
AlgebraicGeometry.Scheme.Cover.exists_lift_trans_eq._proof_1 | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst : CategoryTheory.Category.{u_3, u_2} 𝒰.I₀] [inst_1 : 𝒰.LocallyDirected] {i j : 𝒰.I₀} (k : 𝒰.I₀) (hki : k ⟶ i)
(hkj : k ⟶ j),
... | null | false |
Std.ExtHashMap.contains_of_contains_filter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Bool} {k : α},
(Std.ExtHashMap.filter f m).contains k = true → m.contains k = true | null | true |
CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalNat_i₀ | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (pq : ℕ × ℕ) (hr : 2 ≤ r),
CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalNat.i₀ r pq hr = WithBotTop.coe (↑pq.2 - r + 2) | null | true |
ContinuousLinearMap.compLeftContinuousBounded._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ (α : Type u_1) {β : Type u_3} {γ : Type u_2} {𝕜 : Type u_4} [inst : TopologicalSpace α]
[inst_1 : SeminormedAddCommGroup β] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 β]
[inst_4 : SeminormedAddCommGroup γ] [inst_5 : NormedSpace 𝕜 γ] (g : β →L[𝕜] γ)
(f g_1 : BoundedContinuousFunction α β),... | null | false |
Equiv.seminormedCommGroup | Mathlib.Analysis.Normed.Module.TransferInstance | {α : Type u_1} → {β : Type u_2} → [SeminormedCommGroup β] → α ≃ β → SeminormedCommGroup α | Transfer a `SeminormedCommGroup` across an `Equiv` | true |
CategoryTheory.NatTrans.CommShift.isoRefl_hom | 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_5)
[inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A]
[inst_5 : F₁.CommShift A], CategoryThe... | null | true |
Lean.Grind.CommRing.eq_normEq0_cert | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Bool | null | true |
AddOreLocalization.oreSub_vadd_char | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {X : Type u_2}
[inst_2 : AddAction R X] (r₁ : R) (r₂ : X) (s₁ s₂ : ↥S) (r' : R) (s' : ↥S),
↑s' + r₁ = r' + ↑s₂ → (r₁ -ₒ s₁) +ᵥ r₂ -ₒ s₂ = (r' +ᵥ r₂) -ₒ (s' + s₁) | A characterization lemma for the vector addition on the Ore localization,
allowing for a choice of Ore minuend and Ore subtrahend. | true |
upperClosure_eq | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, ↑(upperClosure s) = s ↔ IsUpperSet s | null | true |
IsUpperSet.isOpen | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [WellFoundedGT α] {s : Set α},
IsUpperSet s → IsOpen s | null | true |
Subtype.instMin._proof_1 | Init.Data.Subtype.Order | ∀ {α : Type u_1} [inst : Min α] [Std.MinEqOr α] {P : α → Prop} (a b : Subtype P), P (↑a ⊓ ↑b) | null | false |
_private.Mathlib.Tactic.ClickSuggestions.0.Mathlib.Tactic.ClickSuggestions.rpc.match_6 | Mathlib.Tactic.ClickSuggestions | (motive : Lean.SubExpr.GoalLocation → Sort u_1) →
(x : Lean.SubExpr.GoalLocation) →
((h : Lean.FVarId) → motive (Lean.SubExpr.GoalLocation.hyp h)) →
((x : Lean.SubExpr.GoalLocation) → motive x) → motive x | null | false |
hasDerivAt_mul_const | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} (c : 𝕜), HasDerivAt (fun x => x * c) c x | null | true |
instLindelofSpaceOfCompactSpace | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactSpace X], LindelofSpace X | A compact space `X` is Lindelöf. | true |
Vector.append_eq_append_iff._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m k l : ℕ}, k + l = n + m → n ≤ k → n + (k - n) = k | null | false |
CliffordAlgebra.hom_ext | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {A : Type u_4} [inst_3 : Semiring A] [inst_4 : Algebra R A] {f g : CliffordAlgebra Q →ₐ[R] A},
f.toLinearMap ∘ₗ CliffordAlgebra.ι Q = g.toLinearMap ∘ₗ CliffordAlgebra.ι Q → f = g | See note [partially-applied ext lemmas]. | true |
CategoryTheory.curryingIso_inv_toFunctor_obj_obj_map | Mathlib.CategoryTheory.Category.Cat.CartesianClosed | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C) {X_1 Y : D}
(g : X_1 ⟶ Y),
((CategoryTheory.curryingIso.inv.toFunctor.obj F).obj X).map... | null | true |
CategoryTheory.Center.instMonoidalOfBraided._proof_24 | Mathlib.CategoryTheory.Monoidal.Center | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor ((CategoryTheory.Center.ofBraided C).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(Category... | null | false |
Set.inter_union_distrib_right | Mathlib.Data.Set.Basic | ∀ {α : Type u} (s t u : Set α), s ∩ t ∪ u = (s ∪ u) ∩ (t ∪ u) | null | true |
nhds_subtype | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] (s : Set X) (x : { x // x ∈ s }), nhds x = Filter.comap Subtype.val (nhds ↑x) | null | true |
Nat.choose_mono | Mathlib.Data.Nat.Choose.Basic | ∀ (b : ℕ), Monotone fun a => a.choose b | null | true |
iSup_inf_le_iSup_inf | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_1} {ι : Sort u_3} [inst : CompleteLattice α] (f : ι → α) (a : α), ⨆ i, f i ⊓ a ≤ (⨆ i, f i) ⊓ a | null | true |
_private.Init.Data.SInt.Lemmas.0.Int8.toNatClampNeg_pos_iff._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (0 < n) = (n ≠ 0) | null | false |
Preord.ext | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} {f g : X ⟶ Y},
(∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) → f = g | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtractAndExtendTarget.recOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{outWidth : ℕ} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.blastExtractAndExtendTarget aig outWidth → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.bitblast.blastExtractAndExtendTarget aig out... | null | false |
Mathlib.Tactic.Linarith.PreprocessorBase.name._autoParam | Mathlib.Tactic.Linarith.Datatypes | Lean.Syntax | null | false |
NNReal.rpow_le_rpow_of_exponent_ge | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x : NNReal} {y z : ℝ}, 0 < x → x ≤ 1 → z ≤ y → x ^ y ≤ x ^ z | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.noConfusion | Mathlib.Tactic.Linter.TextBased | {P : Sort u} →
{t t' : Mathlib.Linter.TextBased.ErrorContext✝} →
t = t' → Mathlib.Linter.TextBased.ErrorContext.noConfusionType✝ P t t' | null | false |
_private.Mathlib.Data.Int.Init.0.Int.inductionOn'_sub_one._proof_1_13 | Mathlib.Data.Int.Init | ∀ {motive : ℤ → Sort u_1} {z b : ℤ}, z ≤ b → ¬z = b → motive (b + Int.negSucc (b - z).toNat) = motive (z - 1) | null | false |
wbtw_self_iff | Mathlib.Analysis.Convex.Between | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y : P}, Wbtw R x y x ↔ y = x | null | true |
UInt64.xor_not | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, a ^^^ ~~~b = ~~~(a ^^^ b) | null | true |
GradedMonoid.GMulAction.noConfusion | Mathlib.Algebra.GradedMulAction | {P : Sort u} →
{ιA : Type u_1} →
{ιM : Type u_3} →
{A : ιA → Type u_4} →
{M : ιM → Type u_5} →
{inst : AddMonoid ιA} →
{inst_1 : VAdd ιA ιM} →
{inst_2 : GradedMonoid.GMonoid A} →
{t : GradedMonoid.GMulAction A M} →
{ιA' : Type u_1... | null | false |
_private.Lean.Parser.0.Lean.PrettyPrinter.Parenthesizer.strLit.parenthesizer._regBuiltin.Lean.PrettyPrinter.Parenthesizer.strLit.parenthesizer_1 | Lean.Parser | IO Unit | null | false |
BoundedRandom.recOn | Mathlib.Control.Random | {m : Type u → Type u_1} →
{α : Type u} →
[inst : Preorder α] →
{motive : BoundedRandom m α → Sort u_2} →
(t : BoundedRandom m α) →
((randomR : {g : Type} → (lo hi : α) → lo ≤ hi → [RandomGen g] → RandGT g m { a // lo ≤ a ∧ a ≤ hi }) →
motive { randomR := randomR }) →
... | null | false |
Part.getOrElse_of_dom | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α) (h : a.Dom) [inst : Decidable a.Dom] (d : α), a.getOrElse d = a.get h | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_386 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
SMulCommClass.toDistribMulActionHom._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_3} (N : Type u_2) (A : Type u_1) [inst : Monoid N] [inst_1 : AddMonoid A] [inst_2 : DistribSMul M A]
[inst_3 : DistribMulAction N A] [inst_4 : SMulCommClass M N A] (c : M) (m : N) (x : A),
(SMulCommClass.toMulActionHom N A c).toFun (m • x) = id m • (SMulCommClass.toMulActionHom N A c).toFun x | null | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.MonotoneOn.intervalIntegral_slope_le._proof_1_14 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → 0 < c → Set.uIcc a (a + c) ⊆ Set.uIcc a (b + c) | null | false |
Lean.Lsp.instFromJsonLeanModule.fromJson | Lean.Data.Lsp.Extra | Lean.Json → Except String Lean.Lsp.LeanModule | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.rec | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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.MonoidalCategoryStruct C] →
{motive : CategoryTheory.MonoidalCategory.MonoidalRightActionStruct C D → Sort u} →
((actionO... | null | false |
Lean.Meta.Grind.EMatch.State.thmMap | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → Lean.Meta.Grind.EMatchTheoremsArray | Inactive global theorems. As we internalize terms, we activate theorems as we find their symbols.
Local theorem provided by users are added directly into `newThms`.
| true |
Std.Time.instHAddOffsetOffset_3 | Std.Time.Date.Basic | HAdd Std.Time.Nanosecond.Offset Std.Time.Hour.Offset Std.Time.Nanosecond.Offset | null | true |
FirstOrder.Language.Substructure.giMapComap._proof_3 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_4} [inst : L.Structure M] [inst_1 : L.Structure N]
{f : L.Hom M N} (S : L.Substructure N),
∀ x ∈ S, ∀ (y : M), f y = x → y ∈ FirstOrder.Language.Substructure.comap f S ∧ f y = x | null | false |
_private.Mathlib.Topology.Sequences.0.compactSpace_iff_seqCompactSpace._simp_1_2 | Mathlib.Topology.Sequences | ∀ (X : Type u_1) [inst : TopologicalSpace X], SeqCompactSpace X = IsSeqCompact Set.univ | null | false |
SSet.PtSimplex.RelStruct.mk.injEq | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g : X.PtSimplex n x} {i : Fin (n + 1)}
(map : SSet.stdSimplex.obj { len := n + 1 } ⟶ X)
(δ_castSucc_map :
autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc) map = f.map)
SSet.PtSimplex.RelStruct.δ_castSucc_map._autoPa... | null | true |
Std.Time.instHAddOffsetOffset_28 | Std.Time.Date.Basic | HAdd Std.Time.Hour.Offset Std.Time.Day.Offset Std.Time.Hour.Offset | null | true |
FourierInvAdd.fourierInv_add | Mathlib.Analysis.Fourier.Notation | ∀ {E : Type u_5} {F : outParam (Type u_6)} {inst : Add E} {inst_1 : Add F} {inst_2 : FourierTransformInv E F}
[self : FourierInvAdd E F] (f g : E),
FourierTransformInv.fourierInv (f + g) = FourierTransformInv.fourierInv f + FourierTransformInv.fourierInv g | null | true |
ProbabilityTheory.HasSubgaussianMGF.zero | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsZeroOrProbabilityMeasure μ],
ProbabilityTheory.HasSubgaussianMGF 0 0 μ | null | true |
Std.Iterators.Types.ULiftIterator.mk.sizeOf_spec | Init.Data.Iterators.Combinators.Monadic.ULift | ∀ {α : Type u} {m : Type u → Type u'} {n : Type (max u v) → Type v'} {β : Type u}
{lift : ⦃γ : Type u⦄ → m γ → Std.Iterators.ULiftT n γ} [inst : SizeOf α] [inst_1 : (a : Type u) → SizeOf (m a)]
[inst_2 : (a : Type (max u v)) → SizeOf (n a)] [inst_3 : SizeOf β] (inner : Std.IterM m β),
sizeOf { inner := inner } = ... | null | true |
Nat.setInvOn_digitsAppend_ofDigits | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b : ℕ},
1 < b → ∀ (l : ℕ), Set.InvOn (b.digitsAppend l) (Nat.ofDigits b) {L | L.length = l ∧ ∀ x ∈ L, x < b} {n | n < b ^ l} | null | true |
AddOpposite.instVAdd | Mathlib.Algebra.Opposites | {α : Type u_1} → {β : Type u_2} → [VAdd α β] → VAdd α βᵃᵒᵖ | null | true |
Std.Iterators.Types.Attach.instIterator._proof_1 | Init.Data.Iterators.Combinators.Monadic.Attach | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {P : β → Prop}
(it : Std.IterM m { out // P out }) (step : Std.Shrink it.internalState.inner.Step),
∃ step',
Std.Iterators.Types.Attach.Monadic.modifyStep it step' =
Std.Iterators.Types.Attach.Monadic.modifyStep it step.inflate | null | false |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.VolumeOfBalls.0.MeasureTheory.volume_sum_rpow_le._simp_1_1 | Mathlib.MeasureTheory.Measure.Lebesgue.VolumeOfBalls | ∀ (p : ENNReal) {V : Type u_4} [inst : AddCommGroup V] (x : V), -WithLp.toLp p x = WithLp.toLp p (-x) | null | false |
Std.TreeMap.Raw.keys_filter_key | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {f : α → Bool},
t.WF → (Std.TreeMap.Raw.filter (fun k x => f k) t).keys = List.filter f t.keys | null | true |
OrderEmbedding.sortedLE_listMap._simp_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ↪o β) {l : List α},
(List.map (⇑e) l).SortedLE = l.SortedLE | null | false |
PresheafOfModules.freeYonedaEquiv.eq_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Generator | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M : PresheafOfModules R} {X : C},
PresheafOfModules.freeYonedaEquiv = PresheafOfModules.freeHomEquiv.trans CategoryTheory.yonedaEquiv | null | true |
Lean.MVarId.congrN | Lean.Meta.Tactic.Congr | Lean.MVarId → optParam ℕ 1000000 → optParam Bool true → optParam Bool true → Lean.MetaM (List Lean.MVarId) | Given a goal of the form `⊢ f as = f bs`, `⊢ (p → q) = (p' → q')`, or `⊢ f as ≍ f bs`, try to apply congruence.
It takes proof irrelevance into account, and the fact that `Decidable p` is a subsingleton.
* Applies `congr` recursively up to depth `depth`.
* If `closePre := true`, it will attempt to close new goals
us... | true |
Function.Surjective.semigroup._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₂] [inst_1 : Semigroup M₁] (f : M₁ → M₂),
(∀ (x y : M₁), f (x * y) = f x * f y) → ∀ (x y z : M₁), f x * f y * f z = f x * (f y * f z) | null | false |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.TauPackage.lastStep_nonempty._simp_1_3 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
CochainComplex.instAdditiveHomologicalComplexIntUpShiftFunctor | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n : ℤ),
(CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n).Additive | null | true |
_private.Mathlib.Data.List.Sort.0.List.sortedLE_concat._proof_1_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : LinearOrder α] {a : α}, (l.concat a).SortedLE ↔ (∀ b ∈ l, b ≤ a) ∧ l.SortedLE | null | false |
WithZero.instAddMonoid | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u} → [AddSemigroup α] → AddMonoid (WithZero α) | null | true |
Option.map₂_coe_right | Mathlib.Data.Option.NAry | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : Option α) (b : β),
Option.map₂ f a (some b) = Option.map (fun a => f a b) a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.