name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CochainComplex.HomComplex.leftHomologyData'._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m p : ℤ) (hm : n + 1 = m) (hp : m + 1 = p)
(s :
CategoryTheory.Limits.Cofork
((CochainComplex.HomComplex.Cocycle.isKernel K L m p hp).lift
(CategoryTheory.Limits.Ker... | false |
Std.Slice.Internal.SubarrayData.mk._flat_ctor | Init.Data.Array.Subarray | {α : Type u} →
(array : Array α) → (start stop : ℕ) → start ≤ stop → stop ≤ array.size → Std.Slice.Internal.SubarrayData α | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_7 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | false |
_private.Mathlib.Data.Set.Insert.0.Set.ssubset_insert._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, a ∉ s → s ⊂ insert a s | false |
hasFDerivAt_comp_add_right | 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 : E → F}
{f' : E →L[𝕜] F} {x : E} (a : E), HasFDerivAt (fun x => f (x + a)) f' x ↔ HasFDerivAt f f' (x + a) | true |
Nat.clog_zero_right | Mathlib.Data.Nat.Log | ∀ (b : ℕ), Nat.clog b 0 = 0 | true |
CategoryTheory.nerve.σ₀_mk₀_eq | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : C),
CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve C) 0 (CategoryTheory.ComposableArrows.mk₀ x) =
CategoryTheory.ComposableArrows.mk₁ (CategoryTheory.CategoryStruct.id x) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.Reachable.dist_triangle_right._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V},
G.Reachable v w → ∀ (u : V), G.Reachable u w → ↑(G.dist u w) ≤ ↑(G.dist u v) + ↑(G.dist v w) | false |
instDecidableIff._proof_2 | Init.Core | ∀ {p q : Prop}, p → ¬q → (p ↔ q) → False | false |
_private.Mathlib.Probability.Kernel.Composition.MeasureCompProd.0.MeasureTheory.Measure.compProd_eq_zero_iff._simp_1_1 | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (μ = 0) = (μ Set.univ = 0) | false |
fixingSubgroup_union | Mathlib.GroupTheory.GroupAction.FixingSubgroup | ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α] {s t : Set α},
fixingSubgroup M (s ∪ t) = fixingSubgroup M s ⊓ fixingSubgroup M t | true |
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.forall_uIoc_iff._simp_1_2 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (k i j : ℕ), i + k = j → ¬i ≤ j → False | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_129 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (w_1 start : ℕ)
(expr : Std.Tactic.BVDecide.BVExpr w_1), ¬llhs.shiftLeft lrhs = Std.Tactic.BVDecide.BVExpr.extract start w expr | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_24 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (j k : ℕ),
j < k → k + 1 ≤ (head :: tail).length → (head :: tail).length + 1 ≤ tail.length → j < tail.length | false |
LinearMap.finrank_maxGenEigenspace_eq | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_3} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M]
[inst_3 : Module.Finite K M] (φ : Module.End K M) (μ : K),
Module.finrank K ↥(φ.maxGenEigenspace μ) = Polynomial.rootMultiplicity μ (LinearMap.charpoly φ) | true |
MvPolynomial.universalFactorizationMapPresentation_val | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k) (a : Fin m ⊕ Fin k),
(MvPolynomial.universalFactorizationMapPresentation R n m k hn).val a =
Sum.elim (fun x => MvPolynomial.X x ⊗ₜ[R] 1) (fun x => 1 ⊗ₜ[R] MvPolynomial.X x) a | true |
AlgebraicGeometry.isLocallyNoetherian_iff_of_affine_openCover | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [∀ (i : 𝒰.I₀), AlgebraicGeometry.IsAffine (𝒰.X i)],
AlgebraicGeometry.IsLocallyNoetherian X ↔ ∀ (i : 𝒰.I₀), IsNoetherianRing ↑((𝒰.X i).presheaf.obj (Opposite.op ⊤)) | true |
Convex.mul_sub_lt_image_sub_of_lt_deriv | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {D : Set ℝ},
Convex ℝ D →
∀ {f : ℝ → ℝ},
ContinuousOn f D →
DifferentiableOn ℝ f (interior D) →
∀ {C : ℝ}, (∀ x ∈ interior D, C < deriv f x) → ∀ x ∈ D, ∀ y ∈ D, x < y → C * (y - x) < f y - f x | true |
CategoryTheory.Functor.ι_leftKanExtensionObjIsoColimit_hom_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : Ca... | true |
Std.DTreeMap.Internal.RciSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rci α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | true |
imp_iff_not_or | Mathlib.Logic.Basic | ∀ {a b : Prop}, a → b ↔ ¬a ∨ b | true |
IsTopologicalGroup.leftUniformSpace | Mathlib.Topology.Algebra.IsUniformGroup.Defs | (G : Type u_1) → [inst : Group G] → [inst_1 : TopologicalSpace G] → [IsTopologicalGroup G] → UniformSpace G | true |
Lean.PrettyPrinter.initFn._@.Lean.PrettyPrinter.Parenthesizer.3994661577._hygCtx._hyg.2 | Lean.PrettyPrinter.Parenthesizer | IO Lean.ParserCompiler.CombinatorAttribute | false |
Real.one_lt_sqrt_two | Mathlib.Data.Real.Sqrt | 1 < √2 | true |
_private.Lean.Meta.Injective.0.Lean.Meta.andProjections.go | Lean.Meta.Injective | Lean.Expr → Lean.Expr → Array Lean.Expr → Lean.MetaM (Array Lean.Expr) | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.widePullbackShapeEquivMap.match_3 | Mathlib.CategoryTheory.WithTerminal.Basic | {J : Type u_1} →
(motive :
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝ x ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝¹ y) →
Sort u_2) →
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(f :
... | false |
SMulPosMono | Mathlib.Algebra.Order.Module.Defs | (α : Type u_1) → (β : Type u_2) → [SMul α β] → [Preorder α] → [Preorder β] → [Zero β] → Prop | true |
_private.Batteries.Data.List.Lemmas.0.List.pos_findIdxNth_getElem._proof_1_10 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n : ℕ}
{h : List.findIdxNth p (head :: tail) n < (head :: tail).length},
n = 0 → ¬p head = true → List.findIdxNth p tail 0 < tail.length | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_iff_exists._simp_1_5 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {n : Type u_3} {α : Type u_11} [inst : Semiring α] [inst_1 : DecidableEq n] [inst_2 : Fintype n] [Nonempty n]
{r s : α}, ((Matrix.scalar n) r = (Matrix.scalar n) s) = (r = s) | false |
Lean.Compiler.LCNF.Code.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} → ℕ → Sort (max 1 u) | false |
Std.instCommutativeAnd | Init.Core | Std.Commutative And | true |
IsDenseInducing.casesOn | Mathlib.Topology.DenseEmbedding | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{i : α → β} →
{motive : IsDenseInducing i → Sort u} →
(t : IsDenseInducing i) →
((toIsInducing : Topology.IsInducing i) → (dense : DenseRange i) → motive ⋯) → motive t | false |
ModuleCat.monModuleEquivalenceAlgebra._proof_29 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : AlgCat R) (x : R), id ((algebraMap R ↑A) x) = id ((algebraMap R ↑A) x) | false |
Lean.Elab.Term.ContainsPendingMVar.visit | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Elab.Term.ContainsPendingMVar.M Unit | true |
IntermediateField.AdjoinSimple.norm_gen_eq_prod_roots | Mathlib.RingTheory.Norm.Basic | ∀ {K : Type u_4} {L : Type u_5} {F : Type u_6} [inst : Field K] [inst_1 : Field L] [inst_2 : Field F]
[inst_3 : Algebra K L] [inst_4 : Algebra K F] (x : L),
(Polynomial.map (algebraMap K F) (minpoly K x)).Splits →
(algebraMap K F) ((Algebra.norm K) (IntermediateField.AdjoinSimple.gen K x)) = ((minpoly K x).aroo... | true |
IsTorsion.subgroup | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : Group G], Monoid.IsTorsion G → ∀ (H : Subgroup G), Monoid.IsTorsion ↥H | true |
MvPolynomial.instIsCancelAddOfIsLeftCancelAdd | Mathlib.Algebra.MvPolynomial.Division | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] [IsLeftCancelAdd R], IsCancelAdd (MvPolynomial σ R) | true |
PolishSpace.measurableEquivNatBoolOfNotCountable._proof_1 | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1}, ¬Countable α → ¬Set.univ.Countable | false |
LipschitzWith.integral_inv_smul_sub_mul_tendsto_integral_lineDeriv_mul | Mathlib.Analysis.Calculus.Rademacher | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{C : NNReal} {f g : E → ℝ} {μ : MeasureTheory.Measure E} [FiniteDimensional ℝ E] [μ.IsAddHaarMeasure],
LipschitzWith C f →
MeasureTheory.Integrable g μ →
∀ (v : E),
Filter.Tendsto ... | true |
MeasureTheory.hittingBtwn_mem_Icc | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β}
{n m : ι}, n ≤ m → ∀ (ω : Ω), MeasureTheory.hittingBtwn u s n m ω ∈ Set.Icc n m | true |
Homeomorph.inv.congr_simp | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
Homeomorph.inv G = Homeomorph.inv G | true |
Subgroup.pi_le_iff | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_3} {f : η → Type u_4} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] [Finite η]
{H : (i : η) → Subgroup (f i)} {J : Subgroup ((i : η) → f i)},
Subgroup.pi Set.univ H ≤ J ↔ ∀ (i : η), Subgroup.map (MonoidHom.mulSingle f i) (H i) ≤ J | true |
_private.Mathlib.Combinatorics.Additive.ErdosGinzburgZiv.0.Int.erdos_ginzburg_ziv_prime | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {p : ℕ} [Fact (Nat.Prime p)] {s : Finset ι} (a : ι → ℤ),
s.card = 2 * p - 1 → ∃ t ⊆ s, t.card = p ∧ ↑p ∣ ∑ i ∈ t, a i | true |
Lean.Meta.Grind.getEqc | Lean.Meta.Tactic.Grind.Types | Lean.Expr → optParam Bool false → Lean.Meta.Grind.GoalM (List Lean.Expr) | true |
CategoryTheory.Limits.reflectsColimitsOfSize_of_rightOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor Cᵒᵖ D) [CategoryTheory.Limits.ReflectsLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.rightOp],
CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformFun.«_aux_Mathlib_Topology_UniformSpace_UniformConvergenceTopology___macroRules__private_Mathlib_Topology_UniformSpace_UniformConvergenceTopology_0_UniformFun_term𝒰(_,_,_)_1» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.Macro | false |
Subgroup.exists_index_le_card_of_leftCoset_cover | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {g : ι → G} {s : Finset ι},
⋃ i ∈ s, g i • ↑(H i) = Set.univ → ∃ i ∈ s, (H i).FiniteIndex ∧ (H i).index ≤ s.card | true |
Lean.Meta.Grind.AC.Struct._sizeOf_1 | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.Struct → ℕ | false |
Plausible.Testable.minimizeAux | Plausible.Testable | {α : Sort u_1} →
[inst : Plausible.SampleableExt α] →
{β : α → Prop} →
[(x : α) → Plausible.Testable (β x)] →
Plausible.Configuration →
String →
Plausible.SampleableExt.proxy α →
ℕ →
OptionT Plausible.Gen
((x : Plausible.Sampleabl... | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_8 | Std.Data.DTreeMap.Internal.Operations | ¬0 - 1 ≤ 1 → False | false |
_private.Mathlib.CategoryTheory.CofilteredSystem.0.CategoryTheory.Functor.isMittagLeffler_iff_subset_range_comp._simp_1_1 | Mathlib.CategoryTheory.CofilteredSystem | ∀ {J : Type u} [inst : CategoryTheory.Category.{v_1, u} J] (F : CategoryTheory.Functor J (Type v)),
F.IsMittagLeffler = ∀ (j : J), ∃ i f, F.eventualRange j = Set.range (F.map f) | false |
_private.Mathlib.Analysis.Convex.StrictCombination.0.StrictConvex.centerMass_mem_interior._proof_1_11 | Mathlib.Analysis.Convex.StrictCombination | ∀ {R : Type u_3} {V : Type u_2} {ι : Type u_1} [inst : Field R] {w : ι → R} {z : ι → V} (i : ι) (t : Finset ι)
(i' j' : ι),
i' ∈ insert i t →
j' ∈ insert i t →
z i' ≠ z j' →
w i' ≠ 0 →
w j' ≠ 0 →
(∀ (i'' j'' : ι), i'' ∈ t → j'' ∈ t → z i'' ≠ z j'' → w i'' ≠ 0 → w j'' = 0) →
... | false |
MeasureTheory.Submartingale.condExp_sub_nonneg | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : CompleteSpace E]
{ℱ : MeasureTheory.Filtration ι m0} [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] {f : ι → Ω → E},
Meas... | true |
Ordset.mem | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → α → Ordset α → Bool | true |
Filter.Germ.LiftPred._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} (p : β → Prop) (_f _g : α → β),
_f =ᶠ[l] _g → (∀ᶠ (x : α) in l, p (_f x)) = ∀ᶠ (x : α) in l, p (_g x) | false |
Std.ExtTreeSet.ext_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp] {t₁ t₂ : Std.ExtTreeSet α cmp},
(∀ (k : α), t₁.contains k = t₂.contains k) → t₁ = t₂ | true |
Ring.DirectLimit.lift_injective | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) [Nonempty ι] [IsDirectedOrder ι],
(∀ (i : ι), Fun... | true |
affineIndependent_of_ne_of_mem_of_mem_of_notMem | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p₁ p₂ p₃ : P},
p₁ ≠ p₂ → p₁ ∈ s → p₂ ∈ s → p₃ ∉ s → AffineIndependent k ![p₁, p₂, p₃] | true |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.simp.match_18 | Lean.Compiler.LCNF.Simp.Main | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.C... | false |
_private.Mathlib.Topology.Separation.Basic.0.t0Space_iff_inseparable.match_1_1 | Mathlib.Topology.Separation.Basic | ∀ (X : Type u_1) [inst : TopologicalSpace X] (motive : T0Space X → Prop) (x : T0Space X),
(∀ (h : ∀ ⦃x y : X⦄, Inseparable x y → x = y), motive ⋯) → motive x | false |
FundamentalGroupoidFunctor.prodToProdTop.match_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | (A : TopCat) →
(B : TopCat) →
(motive :
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B)) →
(x ⟶ y) → Sort u_3) →
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
... | false |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_obj_map_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) (X_1 : CategoryTheory.Functor J₂ C)
{X_2 Y : J₁} (f... | true |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.val_map_lt_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Extension | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
PredOrder.prelimitRecOn._proof_4 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α) (h : ¬Order.IsPredPrelimit a),
¬IsMin (Classical.choose ⋯) | false |
Lean.Lsp.ClientCapabilities._sizeOf_inst | Lean.Data.Lsp.Capabilities | SizeOf Lean.Lsp.ClientCapabilities | false |
_private.Mathlib.CategoryTheory.Triangulated.Pretriangulated.0.CategoryTheory.Pretriangulated.Triangle.isZero₃_of_isZero₁₂._simp_1_1 | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | false |
AddMonoidAlgebra.addAddCommMonoid._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] (a : AddMonoidAlgebra R M), 0 + a = a | false |
CategoryTheory.Bicategory.conjugateEquiv_whiskerRight | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {l₁ : a ⟶ b} {r₁ : b ⟶ a}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁) {l₁' : a ⟶ b} {r₁' : b ⟶ a}
(adj₁' : CategoryTheory.Bicategory.Adjunction l₁' r₁') {l₂ : b ⟶ c} {r₂ : c ⟶ b}
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (φ : l₁' ⟶ ... | true |
LinearMap.BilinMap.tensorDistrib._proof_27 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) {M₁ : Type u_3} {N₁ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid N₁] [inst_4 : Algebra R A] [inst_5 : Module A M₁]
[inst_6 : Module R N₁] [inst_7 : Module A N₁] [inst_8 : IsScalarTower R A N₁],
IsScalarTower R A (... | false |
Finset.insert_Ico_right_eq_Ico_succ | Mathlib.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : SuccOrder α] {a b : α} [NoMaxOrder α],
a ≤ b → insert b (Finset.Ico a b) = Finset.Ico a (Order.succ b) | true |
CategoryTheory.Over.grpObjMkPullbackSnd_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R S : C} {f : R ⟶ X} {g : S ⟶ X} [inst_2 : CategoryTheory.GrpObj (CategoryTheory.Over.mk f)],
CategoryTheory.MonObj.one =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε (Ca... | true |
CategoryTheory.Limits.pullback.lift_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
(w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g) {Z_1 : C} (h_1 : X ⟶ Z_1),
CategoryTheory.CategoryStruct.com... | true |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.monovary_iff_exists_monotone._simp_1_1 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
Monovary f g = MonovaryOn f g Set.univ | false |
instFullCondensedTypeCondensedSetUlift | Mathlib.Condensed.Functors | Condensed.ulift.Full | true |
ULift.seminormedCommRing._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (a b : ULift.{u_1, u_2} α), a - b = a + -b | false |
Matrix.IsHermitian.splits_charpoly | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n],
A.IsHermitian → A.charpoly.Splits | true |
Ordinal.instPosMulStrictMono | Mathlib.SetTheory.Ordinal.Arithmetic | PosMulStrictMono Ordinal.{u_4} | true |
CategoryTheory.Lax.LaxTrans.isoMk_inv_as_app | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (app : (a : B) → η.app a ≅ θ.app a)
(naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | true |
CategoryTheory.Functor.IsLocallyFull | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | {C : Type uC} →
[inst : CategoryTheory.Category.{vC, uC} C] →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{vD, uD} D] →
CategoryTheory.Functor C D → CategoryTheory.GrothendieckTopology D → Prop | true |
List.toString | Init.Data.ToString.Basic | {α : Type u_1} → [ToString α] → List α → String | true |
SSet.Subcomplex.PairingCore.mk.inj | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type v} {dim : ι → ℕ}
{simplex : (s : ι) → X.obj (Opposite.op (SimplexCategory.mk (dim s + 1)))} {index : (s : ι) → Fin (dim s + 2)}
{nonDegenerate₁ : ∀ (s : ι), simplex s ∈ X.nonDegenerate (dim s + 1)}
{nonDegenerate₂ : ∀ (s : ι), CategoryTheory.SimplicialObject.δ X (index s)... | true |
symmDiff_sdiff | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b c : α), symmDiff a b \ c = a \ (b ⊔ c) ⊔ b \ (a ⊔ c) | true |
ZMod.LFunction | Mathlib.NumberTheory.LSeries.ZMod | {N : ℕ} → [NeZero N] → (ZMod N → ℂ) → ℂ → ℂ | true |
_private.Lean.Data.Lsp.Ipc.0.Lean.Lsp.Ipc.expandOutgoingCallHierarchy.go | Lean.Data.Lsp.Ipc | ℕ →
Lean.Lsp.CallHierarchyItem →
Array Lean.Lsp.Range → Std.TreeSet String compare → Lean.Lsp.Ipc.IpcM (Lean.Lsp.Ipc.CallHierarchy × ℕ) | true |
Std.DHashMap.Raw.Const.getD_empty | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {a : α} {fallback : β},
Std.DHashMap.Raw.Const.getD ∅ a fallback = fallback | true |
exists_and_self | Init.PropLemmas | ∀ (P : Prop) (Q : P → Prop), (∃ (p : P), Q p) ∧ P ↔ ∃ (p : P), Q p | true |
MvQPF.Pi.repr | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} →
{A : Type u} →
(F : A → TypeVec.{u} n → Type u) →
[inst : (α : A) → MvQPF (F α)] → ⦃α : TypeVec.{u} n⦄ → MvQPF.Pi F α → ↑(MvQPF.Pi.P F) α | true |
Std.TreeSet.get!_erase_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).get! k = default | true |
Polynomial.Splits.eq_X_sub_C_of_single_root | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → ∀ {x : R}, f.roots = {x} → f = Polynomial.C f.leadingCoeff * (Polynomial.X - Polynomial.C x) | true |
Sum.Lex.noMaxOrder | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [NoMaxOrder α] [NoMaxOrder β], NoMaxOrder (Lex (α ⊕ β)) | true |
Lean.Elab.Do.Context.doBlockResultType | Lean.Elab.Do.Basic | Lean.Elab.Do.Context → Lean.Expr | true |
Interval.completeLattice._proof_4 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] (S : Set (Interval α)),
(⊥ ∉ S ∧ ∀ ⦃s : NonemptyInterval α⦄, ↑s ∈ S → ∀ ⦃t : NonemptyInterval α⦄, ↑t ∈ S → s.toProd.1 ≤ t.toProd.2) →
⨆ i, ⨆ (_ : ↑i ∈ S), i.toProd.1 ≤ (⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.1, ⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.2).2 | false |
IsSemitopologicalRing.casesOn | Mathlib.Topology.Algebra.Ring.Basic | {R : Type u_2} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocRing R] →
{motive : IsSemitopologicalRing R → Sort u} →
(t : IsSemitopologicalRing R) →
([toIsSemitopologicalSemiring : IsSemitopologicalSemiring R] →
[toContinuousNeg : ContinuousNeg R] → motive ⋯) →
... | false |
Std.ExtTreeMap.compare_minKey!_modify_eq | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {f : β → β}, cmp (t.modify k f).minKey! t.minKey! = Ordering.eq | true |
MeasureTheory.measurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Mul G] [inst_1 : Inv G] [MeasurableMul₂ G] [MeasurableInv G]
{f g : G → ENNReal} (μ : MeasureTheory.Measure G) [MeasureTheory.SFinite μ],
Measurable f → Measurable g → Measurable (MeasureTheory.mlconvolution f g μ) | true |
Lean.Meta.Canonicalizer.ExprVisited.noConfusion | Lean.Meta.Canonicalizer | {P : Sort u} →
{t t' : Lean.Meta.Canonicalizer.ExprVisited} → t = t' → Lean.Meta.Canonicalizer.ExprVisited.noConfusionType P t t' | false |
metricSpaceOfNormedAddCommGroupOfAddTorsor._proof_4 | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ (V : Type u_1) (P : Type u_2) [inst : NormedAddCommGroup V] [inst_1 : AddTorsor V P] (x y : P),
↑⟨(fun x y => ‖x -ᵥ y‖) x y, ⋯⟩ = ENNReal.ofReal ‖x -ᵥ y‖ | false |
AffineIsometry.continuous | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : Pseudo... | true |
Lean.Server.Watchdog.ServerM | Lean.Server.Watchdog | Type → Type | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.