name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddSubsemigroup.map_equiv_top | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : M ≃+ N), AddSubsemigroup.map ↑f ⊤ = ⊤ | null | true |
Std.ExtDTreeMap.getKey!_maxKey | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {he : t ≠ ∅}, t.getKey! (t.maxKey he) = t.maxKey he | null | true |
MeasureTheory.IsAddFundamentalDomain.measure_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsAddFundamentalDomain G s μ → ∀ (t : Set α), μ t = ∑' (g : G), μ (t ∩... | null | true |
Lean.Elab.Tactic.Ext._aux_Init_Ext___macroRules_Lean_Elab_Tactic_Ext_tacticExt1____1 | Init.Ext | Lean.Macro | `ext1 pat*` is like `ext pat*` except that it only applies a single extensionality theorem rather
than recursively applying as many extensionality theorems as possible.
The `pat*` patterns are processed using the `rintro` tactic.
If no patterns are supplied, then variables are introduced anonymously using the `intros`... | false |
MeasureTheory.empty_mem_closedCompactCylinders | Mathlib.MeasureTheory.Constructions.ClosedCompactCylinders | ∀ {ι : Type u_1} (X : ι → Type u_2) [inst : (i : ι) → TopologicalSpace (X i)],
∅ ∈ MeasureTheory.closedCompactCylinders X | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_integral_adjacent_intervals._simp_1_6 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
String.Legacy.Iterator.Valid | Batteries.Data.String.Lemmas | String.Legacy.Iterator → Prop | Validity for a string iterator. | true |
Matrix.IsDiag.smul | Mathlib.LinearAlgebra.Matrix.IsDiag | ∀ {α : Type u_1} {R : Type u_3} {n : Type u_4} [inst : Zero α] [inst_1 : SMulZeroClass R α] (k : R) {A : Matrix n n α},
A.IsDiag → (k • A).IsDiag | null | true |
OrderIso.Icc._proof_7 | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β] (e : α ≃o β) (x y : α) {a b : ↑(Set.Icc x y)},
{ toFun := fun z => ⟨e ↑z, ⋯⟩, invFun := fun z => ⟨e.symm ↑z, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := fun z => ⟨e ↑z, ⋯⟩, invFun := fun z => ⟨e.symm ↑z, ⋯⟩, left_inv := ⋯, right_inv ... | null | false |
IsDiscreteValuationRing.toEuclideanDomain | Mathlib.RingTheory.DiscreteValuationRing.Basic | (R : Type u_2) → [inst : CommRing R] → [inst_1 : IsDomain R] → [IsDiscreteValuationRing R] → EuclideanDomain R | A noncomputable Euclidean domain structure on a discrete valuation ring, where the GCD algorithm
only takes two steps to terminate. Given `GCD(x,y)`, if `x ∣ y` then `y%x = 0` so we're done in one
step; otherwise `y%x = y` and then `GCD(x,y) = GCD(y,x)` which brings us back to the first case.
See `EuclideanDomain.instI... | true |
Equiv.Perm.pow_mod_orderOf_cycleOf_apply | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} (f : Equiv.Perm α) [inst : DecidableRel f.SameCycle] (n : ℕ) (x : α),
(f ^ (n % orderOf (f.cycleOf x))) x = (f ^ n) x | null | true |
isLowerSet_setOfPred._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {p : α → Prop}, IsLowerSet {a | p a} = Antitone p | null | false |
Lean.MonadDeclNameGenerator.recOn | Lean.CoreM | {m : Type → Type} →
{motive : Lean.MonadDeclNameGenerator m → Sort u} →
(t : Lean.MonadDeclNameGenerator m) →
((getDeclNGen : m Lean.DeclNameGenerator) →
(setDeclNGen : Lean.DeclNameGenerator → m Unit) →
motive { getDeclNGen := getDeclNGen, setDeclNGen := setDeclNGen }) →
motiv... | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.InductionObj.instCoeFunInductionObjForallFinPolynomial | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | {R : Type u_2} →
[inst : CommRing R] → {n : ℕ} → CoeFun (ChevalleyThm.PolynomialC.InductionObj✝ R n) fun x => Fin n → Polynomial R | null | true |
CategoryTheory.Limits.piConstAdj._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasProducts C] (X : C) (Y : Cᵒᵖ),
CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => X) | null | false |
FunctionField.ringOfIntegers.instIsIntegralClosureSubtypeMemSubalgebraPolynomial | Mathlib.NumberTheory.FunctionField | ∀ (F : Type u_1) (K : Type u_2) [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra (Polynomial F) K],
IsIntegralClosure (↥(FunctionField.ringOfIntegers F K)) (Polynomial F) K | null | true |
_private.Mathlib.CategoryTheory.Limits.Constructions.Over.Connected.0.CategoryTheory.Over.preservesLimitsOfShape_forget_of_isConnected._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Over.Connected | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [CategoryTheory.IsConnected J] {B : C},
CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.Over.forget B) | null | false |
Lean.Core.CoreM.toIO' | Lean.CoreM | {α : Type} → Lean.CoreM α → Lean.Core.Context → Lean.Core.State → IO α | null | true |
Aesop.EqualUpToIdsM.Context.mk.injEq | Aesop.Util.EqualUpToIds | ∀ (commonMCtx? : Option Lean.MetavarContext) (mctx₁ mctx₂ : Lean.MetavarContext) (allowAssignmentDiff : Bool)
(commonMCtx?_1 : Option Lean.MetavarContext) (mctx₁_1 mctx₂_1 : Lean.MetavarContext) (allowAssignmentDiff_1 : Bool),
({ commonMCtx? := commonMCtx?, mctx₁ := mctx₁, mctx₂ := mctx₂, allowAssignmentDiff := all... | null | true |
_private.Mathlib.Analysis.Distribution.TemperateGrowth.0.Function.HasTemperateGrowth.of_fderiv._simp_1_1 | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {n : ℕ}, ‖iteratedFDeriv 𝕜 (n + 1) f x‖ = ‖iteratedFDeriv 𝕜 n (fderiv 𝕜 f) x‖ | null | false |
Polynomial.eval_divByMonic_pow_rootMultiplicity_ne_zero | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} (a : R),
p ≠ 0 → Polynomial.eval a (p /ₘ (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p) ≠ 0 | null | true |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkDefEq | Lean.Meta.Tactic.Grind.EMatch | Bool → List Lean.Name → List Lean.Level → Array Lean.Expr → ℕ → Lean.Meta.Grind.CnstrRHS → Lean.Meta.Grind.GoalM Bool | Checks constraints of the form `lhs =/= rhs` and `lhs =?= rhs`.
`expectedResult` is `true` if `lhs` and `rhs` should be definitionally equal.
| true |
UInt16.ofBitVec.sizeOf_spec | Init.SizeOf | ∀ (toBitVec : BitVec 16), sizeOf { toBitVec := toBitVec } = 1 + sizeOf toBitVec | null | true |
WithTop.top_ne_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α}, ⊤ ≠ ↑a | null | true |
Asymptotics.IsTheta.isThetaTVS | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : SeminormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E]
[inst_4 : NormedSpace 𝕜 F] {f : α → E} {g : α → F} {l : Filter α}, f =Θ[l] g → f =Θ[𝕜; l] g | **Alias** of the reverse direction of `Asymptotics.isThetaTVS_iff_isTheta`. | true |
_private.Mathlib.MeasureTheory.Function.Holder.0.ContinuousLinearMap.holder_add_left._simp_1_2 | Mathlib.MeasureTheory.Function.Holder | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f g : α → E} (hf : MeasureTheory.MemLp f p μ) (hg : MeasureTheory.MemLp g p μ),
MeasureTheory.MemLp.toLp f hf + MeasureTheory.MemLp.toLp g hg = MeasureTheory.MemLp.toLp (f + g) ⋯ | null | false |
_private.Mathlib.Data.Int.GCD.0.Nat.P.match_1.eq_1 | Mathlib.Data.Int.GCD | ∀ (motive : ℕ × ℤ × ℤ → Sort u_1) (r : ℕ) (s t : ℤ) (h_1 : (r : ℕ) → (s t : ℤ) → motive (r, s, t)),
(match (r, s, t) with
| (r, s, t) => h_1 r s t) =
h_1 r s t | null | true |
_private.Batteries.Data.UInt.0.UInt32.compare_eq_toNat_compare_toNat._simp_1_2 | Batteries.Data.UInt | ∀ {x y : UInt32}, (x = y) = (x.toNat = y.toNat) | null | false |
instShiftRightISize | Init.Data.SInt.Basic | ShiftRight ISize | null | true |
Int16.sub_mul | Init.Data.SInt.Lemmas | ∀ {a b c : Int16}, (a - b) * c = a * c - b * c | null | true |
IsPrimitiveRoot.squarefree_minpoly_mod | Mathlib.RingTheory.RootsOfUnity.Minpoly | ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K},
IsPrimitiveRoot μ n →
∀ [IsDomain K] [CharZero K] {p : ℕ} [inst_3 : Fact (Nat.Prime p)],
¬p ∣ n → Squarefree (Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ μ)) | The reduction modulo `p` of the minimal polynomial of a root of unity `μ` is squarefree. | true |
AddSubsemigroup.gi._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ (M : Type u_1) [inst : Add M] (x : AddSubsemigroup M), ↑x ⊆ ↑(AddSubsemigroup.closure ↑x) | null | false |
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_properDivisors._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
CategoryTheory.SimplicialObject.id_left_app | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C)
(X_1 : SimplexCategoryᵒᵖ),
(CategoryTheory.CategoryStruct.id X).left.app X_1 = CategoryTheory.CategoryStruct.id (X.left.obj X_1) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_27 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : upper < aig.decls.size) (cond ifTrue ifFalse : Std.Sat.AIG.Fanin)
(hltt : ifTrue.gate < upper) (cstate fstate : Std.Sat.AIG.toCNF.State✝ aig),
Std.Sat.AIG.toCNF.State.IsExtensionBy✝ cstate fstate ifTrue.gate ⋯ →
(Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.ca... | null | false |
CategoryTheory.GrothendieckTopology.preservesLimits_diagramFunctor | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{t, w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(X : C) [CategoryTheory.Lim... | null | true |
Filter.HasBasis.eventuallyConst_iff | Mathlib.Order.Filter.EventuallyConst | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} {ι : Sort u_5} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → (Filter.EventuallyConst f l ↔ ∃ i, p i ∧ ∀ x ∈ s i, ∀ y ∈ s i, f x = f y) | null | true |
Lean.Lsp.instToJsonTextDocumentSyncKind | Lean.Data.Lsp.TextSync | Lean.ToJson Lean.Lsp.TextDocumentSyncKind | null | true |
Lean.Doc.Inline.link.inj | Lean.DocString.Types | ∀ {i : Type u} {content : Array (Lean.Doc.Inline i)} {url : String} {content_1 : Array (Lean.Doc.Inline i)}
{url_1 : String},
Lean.Doc.Inline.link content url = Lean.Doc.Inline.link content_1 url_1 → content = content_1 ∧ url = url_1 | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.carry_extractLsb'_eq_carry._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | null | false |
Finset.image₂_left | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {s : Finset α} {t : Finset β} [inst : DecidableEq α],
t.Nonempty → Finset.image₂ (fun x x_1 => x) s t = s | null | true |
Subarray.toList_mergeSort | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {le : α → α → Bool}, (xs.mergeSort le).toList = (Std.Slice.toList xs).mergeSort le | null | true |
LocallyConstant.instRing._proof_3 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Ring Y] (x x_1 : LocallyConstant X Y),
⇑(x + x_1) = ⇑(x + x_1) | null | false |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁.Hom S₂) (g : S₂.Hom S₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f.f₁ g.f₁) S₃.v₁₂ =
CategoryTheory.CategoryStruct.comp ... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey_insert_le_minKey._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
ProbabilityTheory.integral_continuousLinearMap_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (L : ℝ →L[ℝ] ℝ), ∫ (x : ℝ), L x ∂ProbabilityTheory.gaussianReal μ v = L μ | null | true |
ProfiniteAddGrp.instAddGroupCarrierToTopTotallyDisconnectedSpacePtProfiniteLimitConeCompForget₂ContinuousAddMonoidHomToProfiniteContinuousMap._proof_11 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_1 u_2}),
autoParam
(∀ (n : ℕ)
(x : ↑(Profinite.limitCone (F.comp (CategoryTheory.forget₂ ProfiniteAddGrp.{max u_2 u_1} Profinite))).pt.toTop),
(n + 1) • x = n • x + x)
AddMonoid.nsmul_succ... | null | false |
CStarMatrix.instAddZeroClass._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : AddZeroClass A] (a : CStarMatrix m n A), 0 + a = a | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Girth.0.SimpleGraph.girth_eq_zero._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {G : SimpleGraph α}, G.girth = 0 → ¬3 ≤ G.girth | null | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer.0.SubMulAction.ofStabilizer.inv_conjMap_comp_apply._simp_1_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, (a = b) = (↑a = ↑b) | null | false |
HomotopicalAlgebra.bifibrantObjects | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[HomotopicalAlgebra.CategoryWithCofibrations C] →
[CategoryTheory.Limits.HasInitial C] →
[HomotopicalAlgebra.CategoryWithFibrations C] →
[CategoryTheory.Limits.HasTerminal C] → CategoryTheory.ObjectProperty C | The property that is satisfied by bifibrant objects, i.e. objects
that are both cofibrant and fibrant.
(This is only introduced in order to consider the full subcategory
`BifibrantObject`. Otherwise, the typeclasses `IsCofibrant` and
`IsFibrant` are preferred.) | true |
Units.instStarMul._proof_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (u : Rˣ), star ↑u * star ↑u⁻¹ = 1 | null | false |
_private.Mathlib.LinearAlgebra.FixedSubmodule.0.LinearEquiv.fixedReduce_eq_smul_iff._simp_1_2 | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {R : Type u_4} {V : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] (e : V ≃ₗ[R] V) (x : V),
(↑e).fixedSubmodule.mkQ (e x) = e.fixedReduce ((↑e).fixedSubmodule.mkQ x) | null | false |
DirectLimit.zpow₀_def | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | true |
_private.Mathlib.Topology.Algebra.Valued.ValuativeRel.0.IsValuativeTopology.instValuedValueGroupWithZeroOfIsUniformAddGroup._simp_2 | Mathlib.Topology.Algebra.Valued.ValuativeRel | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x : R} {g : (↑v).ValueGroup₀}, (v x < MonoidWithZeroHom.ValueGroup₀.embedding g) = (v.restrict x < g) | null | false |
SimpleGraph.boxProd | Mathlib.Combinatorics.SimpleGraph.Prod | {α : Type u_1} → {β : Type u_2} → SimpleGraph α → SimpleGraph β → SimpleGraph (α × β) | Box product of simple graphs. It relates `(a₁, b)` and `(a₂, b)` if `G` relates `a₁` and `a₂`,
and `(a, b₁)` and `(a, b₂)` if `H` relates `b₁` and `b₂`. | true |
Finset.addETransformRight_zero | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddGroup α] (x : Finset α × Finset α),
Finset.addETransformRight 0 x = x | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.mkMPairs.loop._unsafe_rec | Lean.Elab.BuiltinNotation | Array Lean.Term → ℕ → Lean.Term → Lean.MacroM Lean.Term | null | false |
CategoryTheory.ObjectProperty.hasInducedTStructure_iff | Mathlib.CategoryTheory.Triangulated.TStructure.Induced | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | true |
List.instLawfulGetElemNatLtLength | Init.GetElem | ∀ {α : Type u_1}, LawfulGetElem (List α) ℕ α fun as i => i < as.length | null | true |
Lean.Grind.Linarith.Expr.rec | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Expr → Sort u} →
motive Lean.Grind.Linarith.Expr.zero →
((i : Lean.Grind.Linarith.Var) → motive (Lean.Grind.Linarith.Expr.var i)) →
((a b : Lean.Grind.Linarith.Expr) → motive a → motive b → motive (a.add b)) →
((a b : Lean.Grind.Linarith.Expr) → motive a → motive b → mo... | null | false |
Batteries.Tactic.«_aux_Batteries_Tactic_HelpCmd___macroRules_Batteries_Tactic_command#help_Term+_____1» | Batteries.Tactic.HelpCmd | Lean.Macro | null | false |
Std.DTreeMap.Const.getThenInsertIfNew? | Std.Data.DTreeMap.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{β : Type v} → Std.DTreeMap α (fun x => β) cmp → α → β → Option β × Std.DTreeMap α (fun x => β) cmp | Checks whether a key is present in a map, returning the associated value, and inserts a value for
the key if it was not found.
If the returned value is `some v`, then the returned map is unaltered. If it is `none`, then the
returned map has a new value inserted.
Equivalent to (but potentially faster than) calling `ge... | true |
Con.toSetoid_inj | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] {c d : Con M}, c.toSetoid = d.toSetoid ↔ c = d | null | true |
KaehlerDifferential.tensorKaehlerEquiv._proof_5 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_3) (S : Type u_2) (A : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing A] [inst_4 : Algebra R A], IsScalarTower A A (TensorProduct R A S) | null | false |
true_iff | Init.SimpLemmas | ∀ (p : Prop), (True ↔ p) = p | null | true |
CategoryTheory.Localization.Preadditive.add'_assoc | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {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.Preadditive C]
{L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
[inst_4 : W.HasLeftCalculusOfFractions] {X Y ... | null | true |
CategoryTheory.ComposableArrows.isoMk₅_hom | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_453✝ ≅ g.obj' 0 _proof_453✝) (app₁ : f.obj' 1 _proof_454✝ ≅ g.obj' 1 _proof_454✝)
(app₂ : f.obj' 2 _proof_455✝ ≅ g.obj' 2 _proof_455✝) (app₃ : f.obj' 3 _proof_456✝ ≅ g.obj' 3 _proof_456... | null | true |
Finset.erase_sdiff_comm | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α) (a : α), s.erase a \ t = (s \ t).erase a | null | true |
Char.isValue | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.DSimproc | Returns `.done` for Char values.
These values should not be unfolded in the symbolic evaluator.
In regular `simp`, the nested raw literal should be prevented from being converted into an
`OfNat.ofNat` application.
| true |
CategoryTheory.Limits.BinaryFan.unop.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
(c : CategoryTheory.Limits.BinaryFan (Opposite.op X) (Opposite.op Y)),
c.unop = CategoryTheory.Limits.BinaryCofan.mk c.fst.unop c.snd.unop | null | true |
IsSMulRegular.nat_of_isAddTorsionFree | Mathlib.Algebra.Regular.SMul | ∀ {M : Type u_3} [inst : AddMonoid M] [HasUniqueDiv M] {n : ℕ}, n ≠ 0 → IsSMulRegular M n | **Alias** of `IsSMulRegular.nat_of_hasUniqueDiv`. | true |
CFC.nnrpow_eq_cfcₙ_real | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalRing A] [inst_2 : TopologicalSpace A] [inst_3 : StarRing A]
[inst_4 : Module ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : Nonneg... | null | true |
CategoryTheory.Limits.isEqualizerCompMono._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : X ⟶ Y}
{c : CategoryTheory.Limits.Fork f g} (i : CategoryTheory.Limits.IsLimit c) {Z : C} (h : Y ⟶ Z)
[hm : CategoryTheory.Mono h]
(s : CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.comp f h) (CategoryTheory.CategoryStruct... | null | false |
_private.Mathlib.Geometry.Euclidean.Volume.Measure.0.MeasureTheory.Measure.euclideanHausdorffMeasure._proof_1 | Mathlib.Geometry.Euclidean.Volume.Measure | IsScalarTower ENNReal ENNReal ENNReal | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Basic.0.Std.DHashMap.Internal.AssocList.forInStep.go._f | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type w'} →
[Monad m] →
((a : α) → β a → δ → m (ForInStep δ)) →
(a : Std.DHashMap.Internal.AssocList α β) →
Std.DHashMap.Internal.AssocList.below (motive := fun a => δ → m (ForInStep δ)) a → δ → m (ForI... | null | false |
_private.Mathlib.RingTheory.Smooth.StandardSmoothOfFree.0.Algebra.Smooth.exists_span_eq_top_isStandardSmooth._simp_1_4 | Mathlib.RingTheory.Smooth.StandardSmoothOfFree | ∀ {R : Type u} [inst : CommSemiring R] {ι : Type u_1} {f : ι → R},
(Ideal.span (Set.range f) = ⊤) = (⨆ i, PrimeSpectrum.basicOpen (f i) = ⊤) | null | false |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.whiskerLeftIso._proof_6 | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ : CategoryTheory.Arrow C) {W : C},
CategoryTheory.Limits.HasColimit
(CategoryTheory.Limits.span
(((CategoryTheory.MonoidalCategory.curriedTensor C).map
... | null | false |
CochainComplex.MappingConeCompHomotopyEquiv.inv | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
{X₁ X₂ X₃ : CochainComplex C ℤ} →
(f : X₁ ⟶ X₂) →
(g : X₂ ⟶ X₃) →
CochainComplex.mappingCone (CochainC... | Given two composable morphisms `f` and `g` in the category of cochain complexes, this
is the canonical morphism (which is a homotopy equivalence) from the mapping cone of
the morphism `mappingCone f ⟶ mappingCone (f ≫ g)` to `mappingCone g`. | true |
Std.DTreeMap.Internal.Impl.get!_diff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h₁ : m₁.WF),
m₂.WF →
∀ {k : α} [inst_1 : Inhabited (β k)],
(m₁.diff m₂ ⋯).get! k = if Std.DTreeMap.Internal.Impl.contains k m₂ = true then default else m₁.get! k | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.apply._sparseCasesOn_2 | Mathlib.Tactic.GRewrite.Core | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.toPiLocalization_surjective_of_discreteTopology.match_1_4 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ (R : Type u_1) [inst : CommSemiring R] (f : PrimeSpectrum R → R) (e : PrimeSpectrum R ≃ ↑(Set.range f))
(a b : ↑(Set.range f)) (x : PrimeSpectrum R) (motive : x ∈ {e.symm a} ∩ {e.symm b} → Prop)
(x_1 : x ∈ {e.symm a} ∩ {e.symm b}), (∀ (ha : x ∈ {e.symm a}) (hb : x ∈ {e.symm b}), motive ⋯) → motive x_1 | null | false |
Finset.Ioo_subset_Ioo_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a₁ a₂ b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α],
a₁ ≤ a₂ → Finset.Ioo a₂ b ⊆ Finset.Ioo a₁ b | null | true |
instCommRingFreeCommRing._proof_39 | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u_1), autoParam (∀ (a : FreeCommRing α), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | null | false |
RelSeries.eraseLast._proof_2 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length - 1)), ↑i < p.length | null | false |
Matrix.instIsOrderedAddMonoid | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜], IsOrderedAddMonoid (Matrix n n 𝕜) | null | true |
_private.Mathlib.Tactic.NormNum.NatLog.0.Mathlib.Meta.NormNum.nat_clog_helper._proof_1_1 | Mathlib.Tactic.NormNum.NatLog | ∀ {b m n : ℕ}, m < Nat.clog b n → Nat.clog b n ≤ m + 1 → Nat.clog b n = m + 1 | null | false |
MellinConvergent.div_const | Mathlib.Analysis.MellinTransform | ∀ {f : ℝ → ℂ} {s : ℂ}, MellinConvergent f s → ∀ (a : ℂ), MellinConvergent (fun t => f t / a) s | null | true |
SaturatedSubmonoid.instTop.eq_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : MulOneClass M],
SaturatedSubmonoid.instTop =
{
top :=
let __src := ⊤;
{ toSubmonoid := __src, mulSaturated := ⋯ } } | null | true |
isUltrametricDist_iff_forall_norm_natCast_le_one | Mathlib.Analysis.Normed.Field.Ultra | ∀ {R : Type u_1} [inst : NormedDivisionRing R], IsUltrametricDist R ↔ ∀ (n : ℕ), ‖↑n‖ ≤ 1 | null | true |
Std.DHashMap.Internal.Raw₀.forIn_eq_forIn_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) {δ : Type w} {m' : Type w → Type w'}
[inst : Monad m'] [LawfulMonad m'] {f : (a : α) → β a → δ → m' (ForInStep δ)} {init : δ},
Std.DHashMap.Raw.forIn f init ↑m = forIn (↑m).toList init fun a b => f a.fst a.snd b | null | true |
CategoryTheory.Limits.kernelSubobjectMap_arrow | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{f : X ⟶ Y} [inst_2 : CategoryTheory.Limits.HasKernel f] {X' Y' : C} {f' : X' ⟶ Y'}
[inst_3 : CategoryTheory.Limits.HasKernel f'] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f'),
Ca... | null | true |
_private.Mathlib.Data.Set.Image.0.Set.exists_subset_image_iff._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (t ⊆ f '' s) = ∃ u ⊆ s, f '' u = t | null | false |
Mathlib.Tactic.BicategoryLike.Mor₂Iso.comp.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (f g h : Mathlib.Tactic.BicategoryLike.Mor₁) (η θ : Mathlib.Tactic.BicategoryLike.Mor₂Iso),
sizeOf (Mathlib.Tactic.BicategoryLike.Mor₂Iso.comp e f g h η θ) =
1 + sizeOf e + sizeOf f + sizeOf g + sizeOf h + sizeOf η + sizeOf θ | null | true |
CategoryTheory.Precoverage.ZeroHypercover.isoMk_inv | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S : C}
{E F : J.ZeroHypercover S} (e : E.toPreZeroHypercover ≅ F.toPreZeroHypercover),
(CategoryTheory.Precoverage.ZeroHypercover.isoMk e).inv = e.inv | null | true |
Finset.sort_range | Mathlib.Data.Finset.Sort | ∀ (n : ℕ), ((Finset.range n).sort fun a b => a ≤ b) = List.range n | null | true |
SemilatInfCat.instConcreteCategoryInfTopHomX | Mathlib.Order.Category.Semilat | CategoryTheory.ConcreteCategory SemilatInfCat fun x1 x2 => InfTopHom x1.X x2.X | null | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.mk.injEq | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} {j : J} (f' : F.obj j ⟶ X)
(w₁ :
autoParam (CategoryTheory.CategoryS... | null | true |
Lean.AddErrorMessageContext.mk | Lean.Exception | {m : Type → Type} →
(Lean.Syntax → Lean.MessageData → m (Lean.Syntax × Lean.MessageData)) → Lean.AddErrorMessageContext m | null | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.forM.match_1.splitter | Batteries.Recycling.RBTree.Lemmas | {α : Type u_1} →
(motive : RBTree.RBNode α → Sort u_2) →
(x : RBTree.RBNode α) →
(Unit → motive RBTree.RBNode.nil) →
((c : RBTree.RBColor) →
(l : RBTree.RBNode α) → (v : α) → (r : RBTree.RBNode α) → motive (RBTree.RBNode.node c l v r)) →
motive x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.