name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.Term.MatchAltView.ref | Lean.Elab.MatchAltView | {k : Lean.SyntaxNodeKinds} → Lean.Elab.Term.MatchAltView k → Lean.Syntax | null | true |
CommSemiRingCat.limitCommSemiring._proof_6 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommSemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommSemiRingCat))).pt), 0 + a ... | null | false |
CategoryTheory.yonedaAddMonObj._proof_5 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.AddMonObj M] (x : Cᵒᵖ),
AddMonCat.ofHom
{ toFun := fun x_1 => CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id x).unop x_1,
map_zero... | null | false |
HomogeneousLocalization.val_pow | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] {𝒜 : ι → σ}
[inst_5 : GradedRing 𝒜] {x : Submonoid A} (y : HomogeneousLocalization 𝒜 x) (n : ℕ), (y ^ n).val = y.val ^ n | null | true |
String.instDecidableEqPos | Init.Data.String.Defs | {s : String} → DecidableEq s.Pos | null | true |
LieAdmissibleRing.ctorIdx | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | {L : Type u_1} → LieAdmissibleRing L → ℕ | null | false |
Lean.Elab.Tactic.instBEqSimpKind.beq | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.SimpKind → Lean.Elab.Tactic.SimpKind → Bool | null | true |
Rep.quotientToCoinvariants | Mathlib.RepresentationTheory.Coinvariants | {k : Type u} →
{G : Type v} →
[inst : CommRing k] →
[inst_1 : Group G] → Rep.{w, u, v} k G → (S : Subgroup G) → [inst_2 : S.Normal] → Rep.{w, u, v} k (G ⧸ S) | Given a normal subgroup `S ≤ G`, a `G`-representation `ρ` induces a `G ⧸ S`-representation on
the coinvariants of `ρ|_S`. | true |
SubsemiringClass.toSemiring._proof_6 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {S : Type u_2} (s : S) {R : Type u_1} [inst : Semiring R] [inst_1 : SetLike S R] [inst_2 : SubsemiringClass S R],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
Std.WP.Assertion.NondetFun.evalsTo_apply_4 | Std.WP.Assertion | ∀ {σ₁ σ₂ σ₃ σ₄ α : Type} (f : σ₁ → σ₂ → σ₃ → σ₄ → α) (a : α) (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃) (s₄ : σ₄),
Std.WP.Assertion.NondetFun.EvalsTo f a s₁ s₂ s₃ s₄ = (f s₁ s₂ s₃ s₄ = a) | null | true |
ShrinkingLemma.PartialRefinement.find | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
(c : Set (ShrinkingLemma.PartialRefinement u s p)) → c.Nonempty → ι → ShrinkingLemma.PartialRefinement u s p | Choice of an element of a nonempty chain of partial refinements. If `i` belongs to one of
`carrier v`, `v ∈ c`, then `find c ne i` is one of these partial refinements. | true |
_private.Mathlib.FieldTheory.Galois.IsGaloisGroup.0.IsGaloisGroup.subgroup._proof_1 | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_2) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] (H : Subgroup G) [hGKL : IsGaloisGroup G K L],
IsGaloisGroup (↥H) (↥(FixedPoints.intermediateField ↥H)) L | null | false |
Algebra.IsSeparable.isAlgebraic | Mathlib.FieldTheory.Separable | ∀ (F : Type u_1) (K : Type u_3) [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K] [Nontrivial F]
[Algebra.IsSeparable F K], Algebra.IsAlgebraic F K | null | true |
Std.DHashMap.Internal.Raw₀.interSmallerFnₘ.eq_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m sofar : Std.DHashMap.Internal.Raw₀ α β) (k : α),
m.interSmallerFnₘ sofar k =
match m.getEntry?ₘ k with
| some kv' => sofar.insertₘ kv'.fst kv'.snd
| none => sofar | null | true |
starRingEnd | Mathlib.Algebra.Star.Basic | (R : Type u) → [inst : CommSemiring R] → [StarRing R] → R →+* R | `star` as a ring endomorphism, for commutative `R`. This is used to denote complex
conjugation, and is available under the notation `conj` in the scope `ComplexConjugate`.
Note that this is the preferred form (over `starRingAut`, available under the same hypotheses)
because the notation `E →ₗ⋆[R] F` for an `R`-conjuga... | true |
Lean.Elab.Term.mkCalcTrans | Lean.Elab.Calc | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr) | null | true |
cantorSetHomeomorphNatToBool._proof_1 | Mathlib.Topology.Instances.CantorSet | Continuous fun x i => bif x i then 2 else 0 | null | false |
UInt32.toInt32_xor | Init.Data.SInt.Bitwise | ∀ (a b : UInt32), (a ^^^ b).toInt32 = a.toInt32 ^^^ b.toInt32 | null | true |
_private.Mathlib.Algebra.MvPolynomial.Eval.0.Algebra.adjoin_range_eq_range_aeval._simp_1_3 | Mathlib.Algebra.MvPolynomial.Eval | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | null | false |
mul_star_self_nonneg._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
(r : R), (0 ≤ r * star r) = True | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.Basic.0.integral_sin_sq._simp_1_5 | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Std.Iter.Total.toExtTreeSet | Std.Data.Iterators.Consumers.Set | {α β : Type w} →
[inst : Std.Iterator α Id β] →
[Std.Iterators.Finite α Id] →
[Std.IteratorLoop α Id Id] →
Std.Iter.Total β →
(cmp : autoParam (β → β → Ordering) Std.Iter.Total.toExtTreeSet._auto_1) →
[Std.TransCmp cmp] → Std.ExtTreeSet β cmp | Traverses the given iterator and stores the emitted values in a `ExtTreeSet`.
This variant terminates after finitely many steps and requires a proof that the iterator is
finite. If such a proof is not available, consider using `Iter.toExtTreeSet`.
| true |
_private.Mathlib.Analysis.CStarAlgebra.Module.Defs.0.CStarModule._aux_Mathlib_Analysis_CStarAlgebra_Module_Defs___unexpand_Inner_inner_1 | Mathlib.Analysis.CStarAlgebra.Module.Defs | Lean.PrettyPrinter.Unexpander | null | false |
AddRightCancelMonoid.ext_iff | Mathlib.Algebra.Group.Ext | ∀ {M : Type u} {m₁ m₂ : AddRightCancelMonoid M}, m₁ = m₂ ↔ HAdd.hAdd = HAdd.hAdd | null | true |
QuaternionAlgebra.instAddCommGroupWithOne._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), ↑↑(Int.negSucc n) = -↑(n + 1) | null | false |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.totallyBounded_iff_finite_residueField._simp_1_7 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
ChartedSpaceCore.chart_mem_atlas | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u_4} [inst : TopologicalSpace H] {M : Type u_5} (self : ChartedSpaceCore H M) (x : M),
self.chartAt x ∈ self.atlas | null | true |
Function.update_left_inj | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} [inst : DecidableEq α] {ι : Sort u_1} {f : α → ι} {i j : α} {a : ι},
(∀ (i : α), f i ≠ a) → (Function.update f i a = Function.update f j a ↔ i = j) | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.String.0.String.Slice.startsWith_slice_eq_false_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ (b : Bool), (b = false) = ¬b = true | null | false |
Submodule.pow_smul_top_le | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m n : ℕ},
m ≤ n → I ^ n • ⊤ ≤ I ^ m • ⊤ | null | true |
_private.Mathlib.Tactic.NormNum.RealSqrt.0.Mathlib.Meta.NormNum.evalRealSqrt._proof_4 | Mathlib.Tactic.NormNum.RealSqrt | ∀ (sℝ : Q(DivisionSemiring ℝ)), «$sℝ» =Q Field.toSemifield.toDivisionSemiring | null | false |
_private.Batteries.Tactic.SqueezeScope.0.Batteries.Tactic._aux_Batteries_Tactic_SqueezeScope___elabRules__private_Batteries_Tactic_SqueezeScope_0_Batteries_Tactic_squeezeWrap_1.match_7 | Batteries.Tactic.SqueezeScope | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.discharger) → Sort u_1) →
(discharger : Option (Lean.TSyntax `Lean.Parser.Tactic.discharger)) →
((discharger : Lean.TSyntax `Lean.Parser.Tactic.discharger) → motive (some discharger)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.discharger)) → motive x)... | null | false |
CategoryTheory.ObjectProperty.SerreClassLocalization.whiskeringLeft_obj_obj | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] (E : Type u'') [inst_4 : CategoryTheory.Category.{v'', u''} E]
[... | null | true |
Complex.commRing._proof_9 | Mathlib.Basic.Complex.Basic | ∀ (a b c : ℂ), a * (b + c) = a * b + a * c | null | false |
PowerSeries.WithPiTopology.summable_prod_of_tendsto_order_atTop_nhds_top | Mathlib.RingTheory.PowerSeries.PiTopology | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommSemiring R] {ι : Type u_2} [inst_2 : LinearOrder ι]
[LocallyFiniteOrderBot ι] {f : ι → PowerSeries R},
Filter.Tendsto (fun i => (f i).order) Filter.atTop (nhds ⊤) → Summable fun x => ∏ i ∈ x, f i | If the order of a family of `PowerSeries` tends to infinity, the collection of all
possible products over `Finset` is summable. | true |
CategoryTheory.Abelian.SpectralObject.dKernelSequence_exact._proof_12 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₂ n₃ : ℤ), autoParam (n₂ + 1 = n₃) CategoryTheory.Abelian.SpectralObject.dKernelSequence_exact._auto_5 → n₂ + 1 = n₃ | null | false |
_private.Init.Data.Array.Erase.0.Array.getElem?_eraseIdx_of_ge._proof_1_2 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, i ≤ j → j < i → False | null | false |
Multiset.attach_map_val' | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (s : Multiset α) (f : α → β), Multiset.map (fun i => f ↑i) s.attach = Multiset.map f s | null | true |
Lean.Meta.mkLE | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Returns `a ≤ b`. This method assumes `a` and `b` have the same type. | true |
CategoryTheory.LeftExactFunctor.forget_obj | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : C ⥤ₗ D), (CategoryTheory.LeftExactFunctor.forget C D).obj F = F.obj | null | true |
_private.Mathlib.CategoryTheory.Join.Basic.0.CategoryTheory.Join.comp.match_1.eq_3 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D]
(motive : (x x_1 x_2 : CategoryTheory.Join C D) → x.Hom x_1 → x_1.Hom x_2 → Sort u_5) (_x : C) (_y _z : D)
(x : (CategoryTheory.Join.left _x).Hom (CategoryTheory.Join.right _y))
(x_1 : (... | null | true |
Lean.Lsp.CompletionList.items | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionList → Array Lean.Lsp.CompletionItem | null | true |
Lean.Lsp.DeleteFile.Options.mk | Lean.Data.Lsp.Basic | Bool → Bool → Lean.Lsp.DeleteFile.Options | null | true |
Set.graphOn_union | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s t : Set α), Set.graphOn f (s ∪ t) = Set.graphOn f s ∪ Set.graphOn f t | null | true |
MeasureTheory.SimpleFunc.nearestPtInd._sunfold | Mathlib.MeasureTheory.Function.SimpleFuncDense | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : PseudoEMetricSpace α] → [OpensMeasurableSpace α] → (ℕ → α) → ℕ → MeasureTheory.SimpleFunc α ℕ | null | false |
CategoryTheory.CostructuredArrow.projectQuotient_factors | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor C D} {T : D} [inst_2 : CategoryTheory.Limits.HasFiniteColimits C]
[inst_3 : CategoryTheory.Limits.PreservesFiniteColimits S] {A : CategoryTheory.CostructuredArrow S T}
... | null | true |
_private.Batteries.Data.Array.Merge.0.Array.merge.go._unary.eq_def | Batteries.Data.Array.Merge | ∀ {α : Type u_1} (lt : α → α → Bool) (xs ys : Array α) (_x : (_ : Array α) ×' (_ : ℕ) ×' ℕ),
Array.merge.go._unary✝ lt xs ys _x =
PSigma.casesOn _x fun acc i =>
PSigma.casesOn i fun i j =>
if hi : i ≥ xs.size then
acc ++
↑(have a := ys;
a.toSubarray j)
els... | null | false |
String.Slice.Pattern.Model.Char.isMatch_iff | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsMatch c pos ↔
∃ (h : s.startPos ≠ s.endPos), pos = s.startPos.next h ∧ s.startPos.get h = c | null | true |
Matrix.toLin'OfInv._proof_3 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_3} {n : Type u_2} [inst_1 : Fintype m] [inst_2 : DecidableEq m]
{M' : Matrix n m R} (x y : m → R),
(Matrix.toLin' M').toFun (x + y) = (Matrix.toLin' M').toFun x + (Matrix.toLin' M').toFun y | null | false |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.Subgroup.0.isCyclic_iff_exists_orderOf_eq_natCard._simp_1_2 | Mathlib.GroupTheory.SpecificGroups.Cyclic.Subgroup | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [Finite ↥H], (H = ⊤) = (Nat.card ↥H = Nat.card G) | null | false |
Relation.TransGen.lift | Mathlib.Logic.Relation | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {p : β → β → Prop} (f : α → β),
r ≤ Function.onFun p f → Relation.TransGen r ≤ Function.onFun (Relation.TransGen p) f | null | true |
CategoryTheory.Presieve.map_singleton | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X Y : C} (f : X ⟶ Y),
CategoryTheory.Presieve.map F (CategoryTheory.Presieve.singleton f) = CategoryTheory.Presieve.singleton (F.map f) | null | true |
Int.lt_neg_iff | Init.Data.Int.Order | ∀ {x y : ℤ}, x < -y ↔ y < -x | null | true |
AbsConvexOpenSets.coe_balanced | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : TopologicalSpace E] [inst_1 : AddCommMonoid E] [inst_2 : SeminormedRing 𝕜]
[inst_3 : SMul 𝕜 E] [inst_4 : PartialOrder 𝕜] (s : AbsConvexOpenSets 𝕜 E), Balanced 𝕜 ↑s | null | true |
Function.mulSupport_nonempty_iff._simp_2 | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M}, (Function.mulSupport f).Nonempty = (f ≠ 1) | null | false |
Ordnode.splitMax'._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → α → Ordnode α → Ordnode α × α | null | false |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Approximations.0.GenContFract.sub_convs_eq._proof_1_4 | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K] {ifp : GenContFract.IntFractPair K},
((GenContFract.of v).contsAux n).a * ((GenContFract.of v).contsAux (n + 1)).b -
((GenContFract.of v).contsAux n).b * ((GenContFract.of v).contsAux (n... | null | false |
AlternatingMap.curryLeftLinearMap._proof_1 | Mathlib.LinearAlgebra.Alternating.Curry | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {n : ℕ}, SMulCommClass R R (M [⋀^Fin n]→ₗ[R] N) | null | false |
Std.PRange.UpwardEnumerable.Map.PreservesRxoSize.casesOn | Init.Data.Range.Polymorphic.Map | {α : Type u_1} →
{β : Type u_2} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
[inst_2 : Std.Rxo.HasSize α] →
[inst_3 : Std.Rxo.HasSize β] →
{f : Std.PRange.UpwardEnumerable.Map α β} →
{motive : f.PreservesRxoSize → Sort u} →... | null | false |
CategoryTheory.Monad.forgetCreatesLimits | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} → CategoryTheory.CreatesLimitsOfSize.{u_1, u_2, v₁, v₁, max u₁ v₁, u₁} T.forget | The forgetful functor from the Eilenberg-Moore category creates limits. | true |
_private.Aesop.Forward.Substitution.0.Aesop.Substitution.cmpExprs | Aesop.Forward.Substitution | Lean.Expr → Lean.Expr → Ordering | null | true |
Lean.Syntax.isAntiquots | Lean.Syntax | Lean.Syntax → Bool | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.assert._regBuiltin.Lean.Parser.Term.assert.docString_3 | Lean.Parser.Term | IO Unit | null | false |
MaxTropical.instDecidableLT.eq_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LT R] [inst_1 : DecidableLT R], MaxTropical.instDecidableLT = inferInstance | null | true |
Cardinal.ofENat_le_ofENat | Mathlib.SetTheory.Cardinal.ENat | ∀ {m n : ℕ∞}, ↑m ≤ ↑n ↔ m ≤ n | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.exp_two_pi_mul_I_mul_div_eq_one_iff._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (∃ c, b = a * c) = (a ∣ b) | null | false |
Lean.Lsp.ClientCapabilities.window?._default | Lean.Data.Lsp.Capabilities | Option Lean.Lsp.WindowClientCapabilities | null | false |
Function.locallyFinsuppWithin.support_neg | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddGroup Y]
(D : Function.locallyFinsuppWithin U Y), (-D).support = D.support | Simplifier lemma: Support does not change when replacing a function with locally finite support by
its negative.
| true |
_private.Mathlib.Geometry.Euclidean.SignedDist.0.Affine.Simplex.signedInfDist_affineCombination._simp_1_4 | Mathlib.Geometry.Euclidean.SignedDist | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
HasFPowerSeriesWithinAt.restrictScalars | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {𝕜' : Type u_9}
[inst_5 : NontriviallyNormedField 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : NormedSpace 𝕜... | null | true |
NFA.evalFrom_iUnion₂ | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) {ι : Sort u_1} {κ : ι → Sort u_2} (f : (i : ι) → κ i → Set σ) (x : List α),
M.evalFrom (⋃ i, ⋃ j, f i j) x = ⋃ i, ⋃ j, M.evalFrom (f i j) x | null | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_natAdd_Ioc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
ImportGraph.WorkspaceModel.Module.ctorIdx | ImportGraph.WorkspaceModel.Model | ImportGraph.WorkspaceModel.Module → ℕ | null | false |
_private.Lean.ResolveName.0.Lean.unresolveNameGlobal?.tryResolve.match_1 | Lean.ResolveName | (motive : Option Lean.MacroScopesView → Sort u_1) →
(view? : Option Lean.MacroScopesView) →
((view : Lean.MacroScopesView) → motive (some view)) → ((x : Option Lean.MacroScopesView) → motive x) → motive view? | null | false |
SimpleGraph.deleteEdges | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} → SimpleGraph V → Set (Sym2 V) → SimpleGraph V | Given a set of vertex pairs, remove all of the corresponding edges from the
graph's edge set, if present.
See also: `SimpleGraph.Subgraph.deleteEdges`. | true |
SheafOfModules.Presentation.map | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
{C' : Type u₂} →
... | Let `F` be a functor from sheaf of `R`-module to sheaf of `S`-module, if `F` preserves
colimits and `F.obj (unit R) ≅ unit S`, given a `P : Presentation M`, then we will get a
`Presentation (F.obj M)`. | true |
Nat.max_self | Init.Data.Nat.Lemmas | ∀ (a : ℕ), max a a = a | null | true |
WithTop.semilatticeSup._proof_2 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : SemilatticeSup α] (x y : WithTop α), y ≤ WithTop.map₂ (fun x1 x2 => x1 ⊔ x2) x y | null | false |
HopfAlgebra.antipodeAlgHomOp._proof_2 | Mathlib.RingTheory.HopfAlgebra.Convolution | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A] (x y : A),
MulOpposite.op ((↑(MulOpposite.opLinearEquiv R) ∘ₗ HopfAlgebraStruct.antipode R) (x * y)) =
MulOpposite.op
((↑(MulOpposite.opLinearEquiv R) ∘ₗ HopfAlgebraStruct.antipode R) x *
(↑(MulO... | null | false |
OpenAddSubgroup.instSetLike.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G],
OpenAddSubgroup.instSetLike = { coe := fun U => ↑↑U, coe_injective := ⋯ } | null | true |
PiLp.instEMetricSpace | Mathlib.Analysis.Normed.Lp.PiLp | (p : ENNReal) →
{ι : Type u_2} →
(α : ι → Type u_3) → [hp : Fact (1 ≤ p)] → [Fintype ι] → [(i : ι) → EMetricSpace (α i)] → EMetricSpace (PiLp p α) | emetric space instance on the product of finitely many emetric spaces, using the `L^p`
edistance, and having as uniformity the product uniformity. | true |
Lean.Meta.Simp.Config.catchRuntime | Init.MetaTypes | Lean.Meta.Simp.Config → Bool | When `true` (default : `true`), then `simp` catches runtime exceptions and
converts them into `simp` exceptions.
| true |
CategoryTheory.BimonObj.one_counit | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} (M : C) [self : CategoryTheory.BimonObj M],
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one CategoryTheory.ComonObj.counit =
CategoryTheory.CategorySt... | null | true |
CategoryTheory.PreOneHypercover.Hom.mapMultiforkOfIsLimit_comp_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} A]
{S : C} {E : CategoryTheory.PreOneHypercover S} {F : CategoryTheory.PreOneHypercover S}
{G : CategoryTheory.PreOneHypercover S} (f : E.Hom F) (P : CategoryTheory.Functor Cᵒᵖ A)
{c : CategoryTheo... | null | true |
Equiv.piCongrLeft_symm_preimage_pi | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} (f : ι' ≃ ι) (s : Set ι') (t : (i : ι) → Set (α i)),
(⇑(Equiv.piCongrLeft α f).symm ⁻¹' s.pi fun i' => t (f i')) = (⇑f '' s).pi t | null | true |
Lean.PersistentEnvExtensionDescr.noConfusion | Lean.Environment | {P : Sort u} →
{α β σ : Type} →
{t : Lean.PersistentEnvExtensionDescr α β σ} →
{α' β' σ' : Type} →
{t' : Lean.PersistentEnvExtensionDescr α' β' σ'} →
α = α' → β = β' → σ = σ' → t ≍ t' → Lean.PersistentEnvExtensionDescr.noConfusionType P t t' | null | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.eventuallyEqSet_iff_inf_principal._simp_1_3 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s t : Set α} {l : Filter α}, (s ≤ᶠ[l] t) = (l ⊓ Filter.principal s ≤ l ⊓ Filter.principal t) | null | false |
FirstOrder.Language.inhabited_FGEquiv_of_IsEmpty_Constants_and_Relations._proof_3 | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_4} [inst : L.Structure M] [inst_1 : L.Structure N]
[inst_2 : IsEmpty L.Constants] (a : ↥⊥), isEmptyElim (isEmptyElim a) = a | null | false |
CategoryTheory.GrothendieckTopology.Point.subsingleton_fiber_obj | Mathlib.CategoryTheory.Sites.Point.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
[CategoryTheory.LocallySmall.{w, v, u} C] {U T : C} (f : U ⟶ T) [CategoryTheory.Mono f]
(hT : CategoryTheory.Limits.IsTerminal T), Subsingleton (Φ.fiber.obj U) | null | true |
left_sup_symmDiff | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), a ⊔ symmDiff a b = a ⊔ b | null | true |
CategoryTheory.FreeMonoidalCategory.unit.elim | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : CategoryTheory.FreeMonoidalCategory C → Sort u_1} →
(t : CategoryTheory.FreeMonoidalCategory C) →
t.ctorIdx = 1 → motive CategoryTheory.FreeMonoidalCategory.unit → motive t | null | false |
FreeAlgebra.Rel.rec | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R]
{motive : (a a_1 : FreeAlgebra.Pre R X) → FreeAlgebra.Rel R X a a_1 → Prop},
(∀ {r s : R}, motive (FreeAlgebra.Pre.ofScalar (r + s)) (FreeAlgebra.Pre.ofScalar r + FreeAlgebra.Pre.ofScalar s) ⋯) →
(∀ {r s : R},
motive (FreeAlgebra.Pre.ofScalar (r * ... | null | false |
CategoryTheory.Over.ConstructProducts.conesEquivCounitIso | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(B : C) →
(F : CategoryTheory.Functor (CategoryTheory.Discrete J) (CategoryTheory.Over B)) →
(CategoryTheory.Over.ConstructProducts.conesEquivInverse B F).comp
(CategoryTheory.Over.ConstructProducts.con... | (Impl) A preliminary definition to avoid timeouts. | true |
Module.rankAtStalk | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | {R : Type uR} → (M : Type uM) → [inst : CommRing R] → [inst_1 : AddCommGroup M] → [Module R M] → PrimeSpectrum R → ℕ | The rank of `M` at the stalk of `p` is the rank of `Mₚ` as a `Rₚ`-module. | true |
Algebra.IsPushout.cancelBaseChange_symm_comp_lTensor | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_8) [inst_1 : CommRing A] [inst_2 : Algebra R A] (C : Type u_11)
[inst_3 : CommRing C] [inst_4 : Algebra R C] [inst_5 : Algebra A C] [inst_6 : IsScalarTower R A C] (S : Type u_12)
[inst_7 : CommRing S] [inst_8 : Algebra R S],
(↑(Algebra.IsPushout.cancelBaseChang... | null | true |
List.map_add_range'._f | Init.Data.List.Range | ∀ {a : ℕ} (x : ℕ)
(f :
Nat.below (motive := fun x =>
∀ (x_1 x_2 : ℕ), List.map (fun x => a + x) (List.range' x_1 x x_2) = List.range' (a + x_1) x x_2) x)
(x_1 x_2 : ℕ), List.map (fun x => a + x) (List.range' x_1 x x_2) = List.range' (a + x_1) x x_2 | null | false |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.IsNat.to_eq.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] {n : ℕ}
(motive : (x x_1 : α) → Mathlib.Meta.NormNum.IsNat x n → ↑n = x_1 → Prop) (x x_1 : α)
(x_2 : Mathlib.Meta.NormNum.IsNat x n) (x_3 : ↑n = x_1), (∀ (_ : Unit), motive ↑n ↑n ⋯ ⋯) → motive x x_1 x_2 x_3 | null | false |
Finset.mem_ssubsets._simp_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, (t ∈ s.ssubsets) = (t ⊂ s) | null | false |
Sum.elim_zero_single | Mathlib.Algebra.Group.Pi.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq β] [inst_2 : Zero γ] (i : β)
(c : γ), Sum.elim 0 (Pi.single i c) = Pi.single (Sum.inr i) c | null | true |
Std.Internal.List.maxKey!_eq_default | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)}, l.isEmpty = true → Std.Internal.List.maxKey! l = default | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.