name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ENormedCommMonoid.enorm_eq_zero | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_8} {inst : TopologicalSpace E} [self : ENormedCommMonoid E] (x : E), ‖x‖ₑ = 0 ↔ x = 1 | true |
OpenPartialHomeomorph.continuousAt_extend_symm' | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} {x : E},
x ∈ (f.extend I).target ... | true |
measurableSet_swap_iff | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set (α × β)},
MeasurableSet (Prod.swap ⁻¹' s) ↔ MeasurableSet s | true |
CategoryTheory.Dial.tensorObjImpl_tgt | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X Y : CategoryTheory.Dial C),
(X.tensorObjImpl Y).tgt = (X.tgt ⨯ Y.tgt) | true |
isOpen_setOf_disjoint_nhds_nhds | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} [inst : TopologicalSpace X], IsOpen {p | Disjoint (nhds p.1) (nhds p.2)} | true |
Bundle.TotalSpace.trivialSnd | Mathlib.Data.Bundle | (B : Type u_4) → (F : Type u_5) → Bundle.TotalSpace F (Bundle.Trivial B F) → F | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.splitCore.match_4 | Lean.Meta.Tactic.Grind.Split | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((falseProof : Lean.Expr) → motive (some falseProof)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | false |
CategoryTheory.ShortComplex.SnakeInput.functorL₁._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).f₁ = CategoryTheory.CategoryStruct.comp f.f₁ g.f₁ | false |
CategoryTheory.Abelian.SpectralObject.dKernelSequence.congr_simp | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X X_1 : CategoryTheory.Abelian.SpectralObject C ι),
X = X_1 →
∀ {i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ f₁_1 : i₀ ⟶ i₁),
f₁ = f₁_1 →
∀ (f₂ f₂_1 : i... | true |
Cardinal.pow_le | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {κ μ : Cardinal.{u}}, Cardinal.aleph0 ≤ κ → μ < Cardinal.aleph0 → κ ^ μ ≤ κ | true |
WithCStarModule.instCStarModuleForall | Mathlib.Analysis.CStarAlgebra.Module.Constructions | {A : Type u_1} →
[inst : NonUnitalCStarAlgebra A] →
[inst_1 : PartialOrder A] →
{ι : Type u_2} →
{E : ι → Type u_3} →
[inst_2 : Fintype ι] →
[inst_3 : (i : ι) → NormedAddCommGroup (E i)] →
[inst_4 : (i : ι) → Module ℂ (E i)] →
[inst_5 : (i : ι) → S... | true |
exists_contMDiff_zero_iff_one_iff_of_isClosed | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
(I : ModelWithCorners ℝ E H) {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[FiniteDimensional ℝ E] [IsManifold I (↑⊤) M] [SigmaCompactSpace M] [T2Space M] {n : ℕ∞} {s t : Se... | true |
lift_rank_le_of_injective_injective | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {R' : Type u'} {M : Type v} {M' : Type v'} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : Ring R'] [inst_4 : AddCommGroup M'] [inst_5 : Module R' M'] (i : R' → R)
(j : M →+ M'),
(∀ (r : R'), i r = 0 → r = 0) →
Function.Injective ⇑j →
(∀ (r : R') (m : M), j (i r ... | true |
FirstOrder.Language.Formula.realize_iff | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {φ ψ : L.Formula α} {v : α → M},
(φ.iff ψ).Realize v ↔ (φ.Realize v ↔ ψ.Realize v) | true |
UniformFun.postcomp_isUniformEmbedding | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] [inst_1 : UniformSpace γ] {f : γ → β},
IsUniformEmbedding f → IsUniformEmbedding (⇑UniformFun.ofFun ∘ (fun x => f ∘ x) ∘ ⇑UniformFun.toFun) | true |
Nat.eight_eq_digitChar._simp_1 | Init.Data.Nat.ToString | ∀ {n : ℕ}, ('8' = n.digitChar) = (n = 8) | false |
List.Perm.subset_congr_left | Mathlib.Data.List.Perm.Basic | ∀ {α : Type u_1} {l₁ l₂ l₃ : List α}, l₁.Perm l₂ → (l₁ ⊆ l₃ ↔ l₂ ⊆ l₃) | true |
CFC.rpow_mul_rpow_neg._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | Lean.Syntax | false |
UniformContinuousOn.comp_tendstoLocallyUniformlyOn | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β]
{F : ι → α → β} {f : α → β} {s : Set α} {p : Filter ι} [inst_2 : UniformSpace γ] {g : β → γ} {t : Set β},
UniformContinuousOn g t →
TendstoLocallyUniformlyOn F f p s →
Set.MapsTo f s t →
... | true |
_private.Init.Data.Vector.Algebra.0.Vector.zero_add._proof_1_2 | Init.Data.Vector.Algebra | ∀ {α : Type u_1} {n : ℕ} [inst : Zero α] [inst_1 : Add α], (∀ (x : α), 0 + x = x) → ∀ (xs : Vector α n), 0 + xs = xs | false |
ContinuousMultilinearMap.curryFinFinset._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_3) (G : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G'] {l : ℕ},
ContinuousAdd (ContinuousMultilinearMap 𝕜 (fun i => G) G') | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.add_mem_iff._simp_1_1 | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
(r ∈ spectrum R a) = ¬IsUnit ((algebraMap R A) r - a) | false |
UniqueFactorizationMonoid.primeFactors_eq_empty_iff | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M}, a ≠ 0 → (UniqueFactorizationMonoid.primeFactors a = ∅ ↔ IsUnit a) | true |
_private.Std.Time.Date.Basic.0.Std.Time.Hour.Offset.ofWeeks._proof_1 | Std.Time.Date.Basic | 86400 * 7 / ↑168 = 3600 | false |
List.head_flatten._proof_2 | Init.Data.List.Find | ∀ {α : Type u_1} {L : List (List α)}, (∃ l ∈ L, l ≠ []) → (List.findSome? List.head? L).isSome = true | false |
HasFDerivAt.fun_add | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{f' g' : E →L[𝕜] F} {x : E}, HasFDerivAt f f' x → HasFDerivAt g g' x → HasFDerivAt (fun i => f i ... | true |
CategoryTheory.AddGrp.instMonoidalMonForget₂Mon._proof_14 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.AddGrp C} (X' : CategoryTheory.AddGrp C)
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
... | false |
_private.Mathlib.Algebra.Order.Floor.Semiring.0.Nat.preimage_Ioc._simp_1_1 | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R} {n : ℕ},
0 ≤ a → (⌊a⌋₊ < n) = (a < ↑n) | false |
USize.toBitVec_inj | Init.Data.UInt.Lemmas | ∀ {a b : USize}, a.toBitVec = b.toBitVec ↔ a = b | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mclearError_1 | Std.Tactic.Do.Syntax | Lean.Macro | false |
Bundle.Trivial.symmL_trivialization | Mathlib.Topology.VectorBundle.Constructions | ∀ (𝕜 : Type u_1) (B : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace B] (x : B),
Bundle.Trivialization.symmL 𝕜 (Bundle.Trivial.trivialization B F) x = ContinuousLinearMap.id 𝕜 F | true |
Lean.Meta.instBEqDefEqCacheKey | Lean.Meta.Basic | BEq Lean.Meta.DefEqCacheKey | true |
List.SortedLE | Mathlib.Data.List.Sort | {α : Type u_1} → [Preorder α] → List α → Prop | true |
ClassGroup.distinctElems | Mathlib.NumberTheory.ClassNumber.Finite | {R : Type u_1} →
{S : Type u_2} →
[inst : EuclideanDomain R] →
[inst_1 : CommRing S] →
[inst_2 : IsDomain S] →
[inst_3 : Algebra R S] →
{abv : AbsoluteValue R ℤ} →
{ι : Type u_5} →
[inst_4 : DecidableEq ι] →
[inst_5 : Fintype ι] →... | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.mkMatcher.match_1 | Lean.Meta.Match.Match | (motive : Option (Lean.Meta.MatcherInfo → Lean.MetaM Unit) → Sort u_1) →
(addMatcher : Option (Lean.Meta.MatcherInfo → Lean.MetaM Unit)) →
((addMatcher : Lean.Meta.MatcherInfo → Lean.MetaM Unit) → motive (some addMatcher)) →
(Unit → motive none) → motive addMatcher | false |
ContinuousMap.instCStarAlgebra._proof_3 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [CompactSpace α] [inst_2 : CStarAlgebra A],
CompleteSpace C(α, A) | false |
Std.Rco.toList | Init.Data.Range.Polymorphic.Iterators | {α : Type u} →
[inst : LT α] →
[DecidableLT α] →
[inst_2 : Std.PRange.UpwardEnumerable α] →
[Std.PRange.LawfulUpwardEnumerable α] → [Std.Rxo.IsAlwaysFinite α] → Std.Rco α → List α | true |
_private.Lean.Compiler.LCNF.ExpandResetReuse.0.Lean.Compiler.LCNF.isSelfOset._sparseCasesOn_3 | Lean.Compiler.LCNF.ExpandResetReuse | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
LinearMap.equivOfDetNeZero._proof_4 | Mathlib.LinearAlgebra.Determinant | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module 𝕜 M],
Finite (Fin (Module.finrank 𝕜 M)) | false |
algebraMap_strictMono | Mathlib.Algebra.Order.Algebra | ∀ {α : Type u_1} (β : Type u_2) [inst : CommSemiring α] [inst_1 : PartialOrder α] [inst_2 : Semiring β]
[inst_3 : PartialOrder β] [inst_4 : Algebra α β] [ZeroLEOneClass β] [Nontrivial β] [SMulPosStrictMono α β],
StrictMono ⇑(algebraMap α β) | true |
Array.size_singleton | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {x : α}, #[x].size = 1 | true |
CategoryTheory.Bimon.trivial | Mathlib.CategoryTheory.Monoidal.Bimon_ | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → [inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Bimon C | true |
Set.iInter_and | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {p q : Prop} (s : p ∧ q → Set α), ⋂ (h : p ∧ q), s h = ⋂ (hp : p), ⋂ (hq : q), s ⋯ | true |
Rack.PreEnvelGroup.unit.elim | Mathlib.Algebra.Quandle | {R : Type u} →
{motive : Rack.PreEnvelGroup R → Sort u_1} →
(t : Rack.PreEnvelGroup R) → t.ctorIdx = 0 → motive Rack.PreEnvelGroup.unit → motive t | false |
tangentMap_snd | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
Std.Roc.HasRcoIntersection.noConfusionType | Init.Data.Range.Polymorphic.PRange | Sort u → {α : Type w} → Std.Roc.HasRcoIntersection α → {α' : Type w} → Std.Roc.HasRcoIntersection α' → Sort u | false |
Fin.reverseInduction._proof_11 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (i : Fin (n + 1)), ↑i ≤ n | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift.0.Std.IterM.step_uLift.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] →
{it : Std.IterM m β} →
(motive : it.Step → Sort u_3) →
(x : it.Step) →
((it' : Std.IterM m β) →
(out : β) →
(h : it.IsPlausibleStep (S... | true |
Units.isRegular | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Monoid R] (a : Rˣ), IsRegular ↑a | true |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_replicate._simp_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} (n : ℕ) (v : α), Array.replicate n v = (List.replicate n v).toArray | false |
_private.Mathlib.Analysis.Normed.Ring.InfiniteSum.0.summable_of_absolute_convergence_real.match_1_1 | Mathlib.Analysis.Normed.Ring.InfiniteSum | ∀ {f : ℕ → ℝ} (motive : (∃ r, Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) Filter.atTop (nhds r)) → Prop)
(x : ∃ r, Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) Filter.atTop (nhds r)),
(∀ (r : ℝ) (hr : Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) Filter.atTop (nhds r)), motive ⋯) → motive... | false |
Measure.eq_prod_of_integral_mul_prod_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {κ : Type u_2} {Z : Type u_3} {Y : κ → Type u_6} {mY : (j : κ) → MeasurableSpace (Y j)}
[inst : (j : κ) → TopologicalSpace (Y j)] [∀ (j : κ), BorelSpace (Y j)] [∀ (j : κ), HasOuterApproxClosed (Y j)]
{mZ : MeasurableSpace Z} [inst_3 : TopologicalSpace Z] [BorelSpace Z] [HasOuterApproxClosed Z] [inst_6 : Fintype κ... | true |
_private.Lean.Server.Completion.CompletionResolution.0.Lean.Lsp.CompletionItem.resolve.match_1 | Lean.Server.Completion.CompletionResolution | (motive : Option Lean.Linter.DeprecationEntry → Sort u_1) →
(x : Option Lean.Linter.DeprecationEntry) →
((param : Lean.Linter.DeprecationEntry) → motive (some param)) →
((x : Option Lean.Linter.DeprecationEntry) → motive x) → motive x | false |
false_of_nontrivial_of_product_domain | Mathlib.Algebra.Ring.Prod | ∀ (R : Type u_6) (S : Type u_7) [inst : Semiring R] [inst_1 : Semiring S] [IsDomain (R × S)] [Nontrivial R]
[Nontrivial S], False | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft.go_get._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft | ∀ {w : ℕ} (distance curr idx : ℕ), idx < w → idx < distance % w → w - distance % w + idx < w | false |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.withDensity_apply_eq_zero'._simp_1_2 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → MeasureTheory.NullMeasurableSet s μ = True | false |
MvPolynomial.mem_map_C_iff | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} {σ : Type v} [inst : CommRing R] {I : Ideal R} {f : MvPolynomial σ R},
f ∈ Ideal.map MvPolynomial.C I ↔ ∀ (m : σ →₀ ℕ), MvPolynomial.coeff m f ∈ I | true |
Std.DTreeMap.Internal.Impl.maxKey!._proof_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 | false |
_private.Mathlib.RingTheory.Morita.Matrix.0.toModuleCatFromModuleCatLinearEquiv._simp_1 | Mathlib.RingTheory.Morita.Matrix | ∀ {α : Type u_9} {β : Type u_10} {inst : Semigroup α} [self : SemigroupAction α β] (x y : α) (b : β),
x • y • b = (x * y) • b | false |
Lean.Compiler.LCNF.Code.setTag.sizeOf_spec | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (fvarId : Lean.FVarId) (cidx : ℕ) (k : Lean.Compiler.LCNF.Code pu)
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_13),
sizeOf (Lean.Compiler.LCNF.Code.setTag fvarId cidx k h) = 1 + sizeOf fvarId + sizeOf cidx + sizeOf k + sizeOf h | true |
Std.Sat.AIG.RelabelNat.State.Inv1.brecOn | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α]
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv1 a a_1 → Prop} {a : ℕ}
{a_1 : Std.HashMap α ℕ} (t : Std.Sat.AIG.RelabelNat.State.Inv1 a a_1),
(∀ (a : ℕ) (a_2 : Std.HashMap α ℕ) (t : Std.Sat.AIG.RelabelNat.State.Inv1 a a_2),
... | true |
_private.Lean.Meta.Tactic.Unfold.0.Lean.Meta.unfold.pre.match_4 | Lean.Meta.Tactic.Unfold | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
(Unit → motive none) → ((r : Lean.Meta.Simp.Result) → motive (some r)) → motive __do_lift | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic.0.CategoryTheory.WithInitial.opEquiv.match_13.eq_2 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ (C : Type u_1) (motive : CategoryTheory.WithTerminal Cᵒᵖ → Sort u_2)
(h_1 : (x : Cᵒᵖ) → motive (CategoryTheory.WithTerminal.of x)) (h_2 : Unit → motive CategoryTheory.WithTerminal.star),
(match CategoryTheory.WithTerminal.star with
| CategoryTheory.WithTerminal.of x => h_1 x
| CategoryTheory.WithTerminal.... | true |
Height.mulHeight₁_eq | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] (x : K),
Height.mulHeight₁ x =
(Multiset.map (fun v => max (v x) 1) Height.AdmissibleAbsValues.archAbsVal).prod *
∏ᶠ (v : ↑Height.AdmissibleAbsValues.nonarchAbsVal), max (↑v x) 1 | true |
_private.Mathlib.Analysis.InnerProductSpace.Subspace.0.«_aux_Mathlib_Analysis_InnerProductSpace_Subspace___macroRules__private_Mathlib_Analysis_InnerProductSpace_Subspace_0_term⟪_,_⟫_1_1» | Mathlib.Analysis.InnerProductSpace.Subspace | Lean.Macro | false |
_private.Init.Data.UInt.Bitwise.0.UInt16.toUSize_not._simp_1_1 | Init.Data.UInt.Bitwise | ∀ (a : UInt16) (b : USize), (a.toUSize = b % 65536) = (a = b.toUInt16) | false |
CategoryTheory.Over.starPullbackIsoStar._proof_1 | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
{Y : C} (Z : C), ((CategoryTheory.Over.star Y).obj Z).hom = CategoryTheory.Limits.prod.fst | false |
CategoryTheory.GrpObj.ctorIdx | Mathlib.CategoryTheory.Monoidal.Grp_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} → {X : C} → CategoryTheory.GrpObj X → ℕ | false |
List.pairwise_append_comm | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop},
(∀ {x y : α}, R x y → R y x) → ∀ {l₁ l₂ : List α}, List.Pairwise R (l₁ ++ l₂) ↔ List.Pairwise R (l₂ ++ l₁) | true |
Matrix.smul_vecMulVec | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : Mul α] [inst_1 : SMul R α] [IsScalarTower R α α]
(r : R) (w : m → α) (v : n → α), Matrix.vecMulVec (r • w) v = r • Matrix.vecMulVec w v | true |
Std.ExtDTreeMap.isEmpty_diff_iff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp],
(t₁ \ t₂).isEmpty = true ↔ ∀ k ∈ t₁, k ∈ t₂ | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Icc_subset_Ico_iff._to_dual_1.match_1_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α} (motive : a₁ ≤ a₂ ∧ b₂ < b₁ → Prop) (x : a₁ ≤ a₂ ∧ b₂ < b₁),
(∀ (h : a₁ ≤ a₂) (h' : b₂ < b₁), motive ⋯) → motive x | false |
_private.Mathlib.Data.Nat.Bits.0.Nat.testBit_bit_succ._simp_1_1 | Mathlib.Data.Nat.Bits | ∀ (n : ℕ), n / 2 = n.div2 | false |
Std.PreorderPackage.mk._flat_ctor | Init.Data.Order.PackageFactories | {α : Type u} →
(le lt : α → α → Prop) →
(beq : α → α → Bool) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), beq a b = true ↔ le a b ∧ le b a) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) → DecidableLE α → DecidableLT α → Std.PreorderPackage α | false |
or_not_of_imp | Mathlib.Logic.Basic | ∀ {a b : Prop}, (a → b) → b ∨ ¬a | true |
UInt8.neg_eq_neg_one_mul | Init.Data.UInt.Lemmas | ∀ (a : UInt8), -a = -1 * a | true |
AddEquiv.toMultiplicative._proof_6 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_1} {H : Type u_2} [inst : AddZeroClass G] [inst_1 : AddZeroClass H]
(f : Multiplicative G ≃* Multiplicative H), Function.LeftInverse f.invFun f.toFun | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.support_getElem_length_sub_one_eq_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v},
p.length - 1 ≤ p.length → p.length - 1 < p.support.length | false |
CategoryTheory.MorphismProperty.overEquivOfIsInitial | Mathlib.CategoryTheory.Comma.Over.StrictInitial | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(P Q : CategoryTheory.MorphismProperty C) →
[P.ContainsIdentities] →
[inst_2 : Q.IsMultiplicative] →
[Q.RespectsIso] →
[CategoryTheory.Limits.HasStrictInitialObjects C] →
(X : C) → CategoryTheory.Lim... | true |
_private.Batteries.Tactic.Lint.Frontend.0.Batteries.Tactic.Lint.instReprLintVerbosity.repr.match_1 | Batteries.Tactic.Lint.Frontend | (motive : Batteries.Tactic.Lint.LintVerbosity → Sort u_1) →
(x : Batteries.Tactic.Lint.LintVerbosity) →
(Unit → motive Batteries.Tactic.Lint.LintVerbosity.low) →
(Unit → motive Batteries.Tactic.Lint.LintVerbosity.medium) →
(Unit → motive Batteries.Tactic.Lint.LintVerbosity.high) → motive x | false |
LieIdeal.restr_eq_iSup_sl2SubmoduleOfRoot | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] [inst_5 : CharZero K]
[inst_6 : LieAlgebra.IsKilling K L] [inst_7 : LieModule.IsTriangularizable K (↥H) L] (I : LieIdeal K L),
Li... | true |
CategoryTheory.Cat.rightUnitor_inv_app | Mathlib.CategoryTheory.Category.Cat | ∀ {B C : CategoryTheory.Cat} (F : B ⟶ C) (X : ↑B),
(CategoryTheory.Bicategory.rightUnitor F).inv.toNatTrans.app X = CategoryTheory.eqToHom ⋯ | true |
WeierstrassCurve.Jacobian.Point.instAddCommGroup._proof_5 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (n : ℕ) (x : W.Point),
nsmulRec (n + 1) x = nsmulRec n x + x | false |
Algebra.adjoin_singleton_induction | Mathlib.RingTheory.Adjoin.Polynomial.Basic | ∀ (R : Type u) {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A)
{M : ↥R[x] → Prop} (a : ↥R[x]), (∀ (p : Polynomial R), M ⟨(Polynomial.aeval x) p, ⋯⟩) → M a | true |
HomologicalComplex.homotopyCofiber.desc._proof_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {F G K : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (α : G ⟶ K) (hα : Homotopy (CategoryTheory.Category... | false |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffAt_iff_nat._simp_1_2 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | false |
Behrend.lower_bound_le_one | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {N : ℕ}, 1 ≤ N → N ≤ 4096 → ↑N * Real.exp (-4 * √(Real.log ↑N)) ≤ 1 | true |
_private.Init.Data.UInt.Lemmas.0.UInt8.instLawfulOrderLT._simp_3 | Init.Data.UInt.Lemmas | ∀ {α : Sort u} {r : α → α → Prop} [self : Std.Total r] (a b : α), (r a b ∨ r b a) = True | false |
CategoryTheory.Limits.DiagramOfCocones | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
CategoryTheory.Functor J (CategoryTheory.Functor K C) → Type (max (max (max (ma... | true |
Lean.Lsp.instOrdDiagnosticRelatedInformation | Lean.Data.Lsp.Diagnostics | Ord Lean.Lsp.DiagnosticRelatedInformation | true |
AddLECancellable.eq_tsub_of_add_eq | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] {a b c : α},
AddLECancellable c → a + c = b → a = b - c | true |
eval_det_add_X_smul | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {n : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_3} [inst_2 : CommRing R]
(A : Matrix n n (Polynomial R)) (M : Matrix n n R),
Polynomial.eval 0 (A + Polynomial.X • M.map ⇑Polynomial.C).det = Polynomial.eval 0 A.det | true |
tendsto_arithGeom_nhds_of_lt_one | Mathlib.Analysis.SpecificLimits.ArithmeticGeometric | ∀ {R : Type u_1} {a b u₀ : R} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [Archimedean R]
[inst_4 : TopologicalSpace R] [OrderTopology R],
0 ≤ a → a < 1 → Filter.Tendsto (arithGeom a b u₀) Filter.atTop (nhds (b / (1 - a))) | true |
Mathlib.Tactic.Ring.Common.Result.rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{E : Q(«$α») → Type u_1} →
{e : Q(«$α»)} →
{motive : Mathlib.Tactic.Ring.Common.Result E e → Sort u} →
((expr : Q(«$α»)) →
(val : E expr) → (proof : Q(«$e» = «$expr»)) → motive { expr := expr, val := val, proof := proof }) →
(t... | false |
_private.Lean.Meta.InferType.0.Lean.Meta.isAlwaysZero._f | Lean.Meta.InferType | (x : Lean.Level) → Lean.Level.below x → Bool | false |
Subbimodule.toSubbimoduleInt | Mathlib.Algebra.Module.Bimodule | (R : Type u_1) →
(S : Type u_2) →
(M : Type u_3) →
[inst : Ring R] →
[inst_1 : Ring S] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : Module S M] →
[inst_5 : SMulCommClass R S M] → Submodule (TensorProduct ℕ R S) M → Submodule (Ten... | true |
Cardinal.sum_eq_lift_iSup_of_lift_mk_le_lift_iSup | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {ι : Type u} [Small.{v, u} ι] {f : ι → Cardinal.{v}},
Cardinal.aleph0 ≤ Cardinal.mk ι →
Cardinal.lift.{v, u} (Cardinal.mk ι) ≤ Cardinal.lift.{u, v} (⨆ i, f i) →
Cardinal.sum f = Cardinal.lift.{u, v} (⨆ i, f i) | true |
CategoryTheory.ShortComplex.fFunctor._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y Z : CategoryTheory.ShortComplex C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Arrow.homMk (CategoryTheory.CategoryStruct.comp f g).τ₁ (CategoryTheory.CategoryStruct.comp f g).τ₂ ⋯ =
CategoryTheor... | false |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.parseUpToHere | Mathlib.Tactic.Linter.Header | String.Pos.Raw → optParam String "" → Lean.Elab.Command.CommandElabM Lean.Syntax | true |
RingHom.surjective_of_tmul_eq_tmul_of_finite | Mathlib.Algebra.Algebra.Epi | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] [Module.Finite R A],
Algebra.IsEpi R A ↔ Function.Surjective ⇑(algebraMap R A) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.