name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
WeierstrassCurve.natDegree_preΨ₄_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R), 2 ≠ 0 → 0 < W.preΨ₄.natDegree | true |
CategoryTheory.Preadditive.ofFullyFaithful._proof_1 | Mathlib.CategoryTheory.Preadditive.Transfer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Preadditive D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
F.map (CategoryTheory.CategoryStruct.comp (f + f') g... | false |
Homotopy.extend.homAux.eq_2 | Mathlib.Algebra.Homology.Embedding.ExtendHomotopy | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
{K L : HomologicalComplex C c} (φ : (i j : ι) → K.X i ⟶ L.X j) (i' : Option ι),
(i' = none → False) → Homotopy.extend.homAux φ... | true |
instNonUnitalNonAssocRingWithConvMatrix._proof_3 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a : WithConv (Matrix m n α)), 0 * a = 0 | false |
AddSubgroup.unop_bot | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : AddGroup G], ⊥.unop = ⊥ | true |
String.Pos.Raw.utf8SetAux.eq_1 | Init.Data.String.Basic | ∀ (c' : Char) (x x_1 : String.Pos.Raw), String.Pos.Raw.utf8SetAux c' [] x x_1 = [] | true |
CategoryTheory.Triangulated.someOctahedron | Mathlib.CategoryTheory.Triangulated.Triangulated | {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 : Ca... | true |
Int.fdiv_eq_tdiv | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ},
a.fdiv b =
a.tdiv b - if b ∣ a then 0 else if 0 ≤ a then if 0 ≤ b then 0 else 1 else if 0 ≤ b then b.sign else 1 + b.sign | true |
Nat.getElem!_toList_roo_eq_add | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, i < n - (m + 1) → (m<...n).toList[i]! = m + 1 + i | true |
Lean.Grind.ToInt.Div.mk | Init.Grind.ToInt | ∀ {α : Type u} [inst : Div α] {I : outParam Lean.Grind.IntInterval} [inst_1 : Lean.Grind.ToInt α I],
(∀ (x y : α), ↑(x / y) = ↑x / ↑y) → Lean.Grind.ToInt.Div α I | true |
Convex.eq_1 | Mathlib.Analysis.Convex.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (s : Set E), Convex 𝕜 s = ∀ ⦃x : E⦄, x ∈ s → StarConvex 𝕜 x s | true |
Polynomial.contract_C | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ) (r : R), Polynomial.contract p (Polynomial.C r) = Polynomial.C r | true |
MeasureTheory.VAddInvariantMeasure.casesOn | Mathlib.MeasureTheory.Group.Defs | {M : Type u_1} →
{α : Type u_2} →
[inst : VAdd M α] →
{x : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.VAddInvariantMeasure M α μ → Sort u} →
(t : MeasureTheory.VAddInvariantMeasure M α μ) →
((measure_preimage_vadd : ∀ (c : M) ⦃s :... | false |
LieAlgebra.lieCharacter_apply_lie' | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(χ : LieAlgebra.LieCharacter R L) (x y : L), ⁅χ x, χ y⁆ = 0 | true |
HSpace.prod._proof_10 | Mathlib.Topology.Homotopy.HSpaces | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : HSpace X]
[inst_3 : HSpace Y] (hG : Continuous fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2))) (x : X × Y),
{ toFun := fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)), continuous_toFu... | false |
quadraticChar_exists_neg_one | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F],
ringChar F ≠ 2 → ∃ a, (quadraticChar F) a = -1 | true |
CategoryTheory.ObjectProperty.prop_of_isColimit_cofan | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderFiniteCoproducts] {J : Type u_2} [Finite J] {f : J → C} {F : CategoryTheory.Limits.Cofan f}
(hF : CategoryTheory.Limits.IsColimit F), (∀ (j : J), P (f j)) → P F.pt | true |
Std.TreeMap.Raw.WF.emptyc | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, ∅.WF | true |
Finset.noncommSum_lemma | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid β] (s : Finset α) (f : α → β),
(↑s).Pairwise (Function.onFun AddCommute f) → {x | x ∈ Multiset.map f s.val}.Pairwise AddCommute | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (k : ℤ) (y? : Option Int.Linear.Var) (c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod k y? c) = 1 + sizeOf k + sizeOf y? + sizeOf c | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution.congr_simp | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, ... | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.saveBVar | Lean.Meta.Tactic.Grind.EMatchTheorem | ℕ → Lean.Meta.Grind.NormalizePattern.M✝ Unit | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Decomp.0.SimpleGraph.Walk.dropUntil_eq_drop._proof_1_13 | Mathlib.Combinatorics.SimpleGraph.Walks.Decomp | ∀ {V : Type u_1} {G : SimpleGraph V} {w : V} [inst : DecidableEq V] {a v w_1 : V} (h : G.Adj a v) (p : G.Walk v w_1),
(∀ (h : w ∈ p.support), (p.dropUntil w h).support = ((p.drop (List.idxOf w p.support)).copy ⋯ ⋯).support) →
∀ (h_1 : w ∈ (SimpleGraph.Walk.cons h p).support) (h' : w ≠ a),
(if hx : a = w the... | false |
Polynomial.separable_cyclotomic | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_2) [inst : Field K] [NeZero ↑n], (Polynomial.cyclotomic n K).Separable | true |
Nat.bit_mod_two | Mathlib.Data.Nat.BinaryRec | ∀ (b : Bool) (n : ℕ), Nat.bit b n % 2 = b.toNat | true |
Squash.mk | Init.Core | {α : Sort u} → α → Squash α | true |
continuous_finsum | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid M] [ContinuousAdd M] {f : ι → X → M},
(∀ (i : ι), Continuous (f i)) →
(LocallyFinite fun i => Function.support (f i)) → Continuous fun x => ∑ᶠ (i : ι), f i x | true |
Mathlib.Tactic.ITauto.Context.format | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Context → Std.Format | true |
Erased.instToString | Mathlib.Data.Erased | (α : Type u) → ToString (Erased α) | true |
_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.maxPowDvdDiv.match_1.eq_1 | Mathlib.Data.Nat.MaxPowDiv | ∀ (motive : ℕ × ℕ → Sort u_1) (e q : ℕ) (h_1 : (e q : ℕ) → motive (e, q)),
(match (e, q) with
| (e, q) => h_1 e q) =
h_1 e q | true |
FiniteDimensional.nonempty_continuousLinearEquiv_of_finrank_eq | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] {F : Type w} [inst_5 : AddCommGroup F]
[inst_6 : Module 𝕜 F] [inst_7 : TopologicalSpace F] [IsTopologicalAddGroup F] [Contin... | true |
Matrix.transposeᵣ.eq_2 | Mathlib.Data.Matrix.Reflection | ∀ {α : Type u_1} (x n : ℕ) (A : Matrix (Fin x) (Fin (n + 1)) α),
A.transposeᵣ = Matrix.of (Matrix.vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ).transposeᵣ) | true |
_private.Init.Data.SInt.Lemmas.0.Int32.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x < y) = (x.toInt < y.toInt) | false |
Lean.instInhabitedScopedEnvExtension.default | Lean.ScopedEnvExtension | {a : Type} → [Inhabited a] → {a_1 a_2 : Type} → Lean.ScopedEnvExtension a a_1 a_2 | true |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.solveMonoCall._sparseCasesOn_1 | Lean.Elab.Tactic.Monotonicity | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Init.Data.String.Iterate.0.String.Slice.revBytes._proof_1 | Init.Data.String.Iterate | ∀ (s : String.Slice), s.endPos.offset ≤ s.rawEndPos | false |
MonadFinally | Init.Control.Except | (Type u → Type v) → Type (max (u + 1) v) | true |
LinearAlgebra.FreeProduct.ι' | Mathlib.LinearAlgebra.FreeProduct.Basic | {I : Type u} →
[inst : DecidableEq I] →
(R : Type v) →
[inst_1 : CommSemiring R] →
(A : I → Type w) →
[inst_2 : (i : I) → Semiring (A i)] →
[inst_3 : (i : I) → Algebra R (A i)] → (DirectSum I fun i => A i) →ₗ[R] LinearAlgebra.FreeProduct R A | true |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (hf₁ : S₁.f = 0) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(hc₁ : CategoryTheory.Limits.IsLimit c₁) (hf₂ : S₂.f = 0) (c₂ : CategoryTheory.Limits... | true |
Tactic.ComputeAsymptotics.Seq.dist_nil_cons | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (x : α) (s : Stream'.Seq α), dist Stream'.Seq.nil (Stream'.Seq.cons x s) = 1 | true |
Module.Grassmannian._sizeOf_1 | Mathlib.RingTheory.Grassmannian | {R : Type u} →
{inst : CommRing R} →
{M : Type v} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → {k : ℕ} → [SizeOf R] → [SizeOf M] → Module.Grassmannian R M k → ℕ | false |
Lean.IR.CollectMaps.collectParams | Lean.Compiler.IR.EmitUtil | Array Lean.IR.Param → Lean.IR.CollectMaps.Collector | true |
Subsemiring.distribMulAction | Mathlib.Algebra.Ring.Subsemiring.Basic | {R' : Type u_1} →
{α : Type u_2} →
[inst : Semiring R'] →
[inst_1 : AddMonoid α] → [DistribMulAction R' α] → (S : Subsemiring R') → DistribMulAction (↥S) α | true |
UniformSpace.ofCoreEq._proof_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} (u : UniformSpace.Core α) (t : TopologicalSpace α),
t = u.toTopologicalSpace → ∀ (x : α), nhds x = Filter.comap (Prod.mk x) u.uniformity | false |
CategoryTheory.faithful_linearYoneda | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C],
(CategoryTheory.linearYoneda R C).Faithful | true |
Prod.finite_iff | Mathlib.Data.Finite.Prod | ∀ {α : Type u_1} {β : Type u_2} [Nonempty α] [Nonempty β], Finite (α × β) ↔ Finite α ∧ Finite β | true |
Std.DTreeMap.Internal.Impl.erase._proof_15 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l r : Std.DTreeMap.Internal.Impl α β)
(h : (Std.DTreeMap.Internal.Impl.inner sz k' v' l r).Balanced) (l' : Std.DTreeMap.Internal.Impl α β)
(hl'₁ : l'.Balanced) (hl'₂ : l.size - 1 ≤ l'.size) (hl'₃ : l'.size ≤ l.size),
(Std.DTreeMap.Internal.Impl.ba... | false |
_private.Init.Data.Array.Lemmas.0.Array.back_append_right._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, 0 < ys.size → ¬0 < xs.size + ys.size → False | false |
Lean.Widget.WidgetSource.rec | Lean.Widget.UserWidget | {motive : Lean.Widget.WidgetSource → Sort u} →
((sourcetext : String) → motive { sourcetext := sourcetext }) → (t : Lean.Widget.WidgetSource) → motive t | false |
MeasureTheory.LocallyIntegrable.exists_nat_integrableOn | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X} [SecondCountableTopology X],
MeasureTheory.LocallyIntegrable f μ →
∃ u, (∀ (n : ℕ), IsOpen (u n)) ∧ ⋃ n, u n = Set.univ ∧ ... | true |
ComplexShape.χ | Mathlib.Algebra.Homology.EulerCharacteristic | {ι : Type u_1} → (c : ComplexShape ι) → [c.EulerCharSigns] → ι → ℤˣ | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.BadChar.rec | Mathlib.NumberTheory.LSeries.Nonvanishing | {N : ℕ} →
[inst : NeZero N] →
{motive : DirichletCharacter.BadChar✝ N → Sort u} →
((χ : DirichletCharacter ℂ N) →
(χ_ne : χ ≠ 1) →
(χ_sq : χ ^ 2 = 1) →
(hχ : DirichletCharacter.LFunction χ 1 = 0) → motive { χ := χ, χ_ne := χ_ne, χ_sq := χ_sq, hχ := hχ }) →
(t : Di... | false |
_private.Mathlib.GroupTheory.GroupAction.MultipleTransitivity.0.SubMulAction.ofFixingSubgroup.isMultiplyPretransitive._simp_1_2 | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ {G : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Group G] [inst_1 : MulAction G β] (g : G) (f : α ↪ β) (a : α),
g • f a = (g • f) a | false |
PositiveLinearMap.preGNS_norm_def | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] (f : A →ₚ[ℂ] ℂ) [inst_2 : StarOrderedRing A]
(a : f.PreGNS), ‖a‖ = √(f (star (f.ofPreGNS a) * f.ofPreGNS a)).re | true |
Subgroup.Normal.conj_smul_eq_self | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : Group G] (g : G) (H : Subgroup G) [h : H.Normal], MulAut.conj g • H = H | true |
_private.Init.Data.Nat.SOM.0.Nat.SOM.Mon.mul.go.match_1.eq_2 | Init.Data.Nat.SOM | ∀ (motive : Nat.SOM.Mon → Nat.SOM.Mon → Sort u_1) (m₂ : Nat.SOM.Mon) (h_1 : (m₁ : Nat.SOM.Mon) → motive m₁ [])
(h_2 : (m₂ : Nat.SOM.Mon) → motive [] m₂)
(h_3 :
(v₁ : Nat.Linear.Var) →
(m₁ : List Nat.Linear.Var) → (v₂ : Nat.Linear.Var) → (m₂ : List Nat.Linear.Var) → motive (v₁ :: m₁) (v₂ :: m₂)),
(m₂ = [... | true |
AlgebraicGeometry.specTargetImageFactorization._proof_1 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {A : CommRingCat} (f : X ⟶ AlgebraicGeometry.Spec A),
AlgebraicGeometry.specTargetImageIdeal f ≤ AlgebraicGeometry.specTargetImageIdeal f | false |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.tendsto_nhds_top_iff_real._simp_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | false |
Real.sinOrderIso._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Real.sin '' Set.Icc (-(Real.pi / 2)) (Real.pi / 2) = Set.Icc (-1) 1 | false |
UInt8.not_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, ¬a ≤ b ↔ b < a | true |
Std.BundledIterM.Equiv._proof_1 | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ (m : Type u_1 → Type u_2) (β : Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m]
(R S : Std.BundledIterM m β → Std.BundledIterM m β → Prop),
Lean.Order.PartialOrder.rel R S →
∀ (ita itb : Std.BundledIterM m β),
Std.Iterators.HetT.map (Std.IterStep.mapIterator (Quot.mk S)) ita.step =
Std.Iter... | false |
RestrictedProduct.mk.congr_simp | Mathlib.Topology.Algebra.RestrictedProduct.Units | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} (x x_1 : (i : ι) → R i) (e_x : x = x_1)
(hx : ∀ᶠ (i : ι) in 𝓕, x i ∈ A i), RestrictedProduct.mk x hx = RestrictedProduct.mk x_1 ⋯ | true |
Matrix.toMatrix₂Aux_toLinearMap₂'Aux | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ (R : Type u_1) {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : Semiring R₁] [inst_2 : Semiring S₁] [inst_3 : Semiring R₂]
[inst_4 : Semiring S₂] [inst_5 : AddCommMonoid N₂] [inst_6 : Module R N₂] [inst_7 : Module S₁... | true |
LowerSet.prod_self_lt_prod_self._simp_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_1} [inst : Preorder α] {s₁ s₂ : LowerSet α}, (s₁ ×ˢ s₁ < s₂ ×ˢ s₂) = (s₁ < s₂) | false |
Lean.Meta.Grind.Methods.evalTactic | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Methods → Lean.Meta.Grind.EvalTactic | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_3 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ}, ∀ k ≤ n, ¬k + 1 ≤ n + 3 → False | false |
Algebra.exists_aeval_invOf_eq_zero_of_idealMap_adjoin_sup_span_eq_top | Mathlib.RingTheory.Polynomial.Ideal | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x : S) (I : Ideal R),
I ≠ ⊤ →
∀ [inst_3 : Invertible x],
Ideal.map (algebraMap R ↥R[x]) I ⊔ Ideal.span {⟨x, ⋯⟩} = ⊤ →
∃ p, p.leadingCoeff - 1 ∈ I ∧ (Polynomial.aeval ⅟x) p = 0 | true |
OrderedFinpartition.extendLeft._proof_14 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n) (i : Fin c.length), 0 < Fin.cons 1 c.partSize i.succ | false |
Lean.Meta.Match.Overlaps.noConfusionType | Lean.Meta.Match.MatcherInfo | Sort u → Lean.Meta.Match.Overlaps → Lean.Meta.Match.Overlaps → Sort u | false |
BoundedContinuousFunction.instModule'._proof_8 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} {𝕜 : Type u_3} [inst : NormedField 𝕜] [inst_1 : TopologicalSpace α]
[inst_2 : SeminormedAddCommGroup β] [inst_3 : NormedSpace 𝕜 β] (f : BoundedContinuousFunction α β), 1 • f = f | false |
CategoryTheory.Triangulated.Octahedron.map_m₁ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Limits.HasZeroObject D] [inst_6 : Ca... | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic.0.CategoryTheory.IsPullback.of_iso'._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | false |
IsPurelyInseparable.surjective_algebraMap_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u_1) (E : Type u_2) [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E] [IsPurelyInseparable F E]
[Algebra.IsSeparable F E], Function.Surjective ⇑(algebraMap F E) | true |
CategoryTheory.Lax.OplaxTrans.homCategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {X Y : F ⟶ G} (f : CategoryTheory.Lax.OplaxTrans.Hom X Y),
{ as := f.as.vcomp { as := CategoryTheory.Lax.OplaxTrans.Modification.id Y }.as } = f | false |
Lean.Elab.CheckTactic.expandCheckSimp._regBuiltin.Lean.Elab.CheckTactic.expandCheckSimp.declRange_3 | Lean.Elab.CheckTactic | IO Unit | false |
Lean.Order.CompleteLattice.casesOn | Init.Internal.Order.Basic | {α : Sort u} →
{motive : Lean.Order.CompleteLattice α → Sort u_1} →
(t : Lean.Order.CompleteLattice α) →
([toPartialOrder : Lean.Order.PartialOrder α] →
(has_sup : ∀ (c : α → Prop), Exists (Lean.Order.is_sup c)) →
motive { toPartialOrder := toPartialOrder, has_sup := has_sup }) →
... | false |
Matrix.transpose_fromRows | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} (A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R),
(A₁.fromRows A₂).transpose = A₁.transpose.fromCols A₂.transpose | true |
LinearMap.ofIsCompl_eq_add | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {p q : Submodule R E} (hpq : IsCompl p q) {φ : ↥p →ₗ[R] F}
{ψ : ↥q →ₗ[R] F}, LinearMap.ofIsCompl hpq φ ψ = φ ∘ₗ p.linearProjOfIsCompl q hpq + ψ ∘ₗ q.linearPr... | true |
RingEquiv.prodProdProdComm._proof_3 | Mathlib.Algebra.Ring.Prod | ∀ (R : Type u_2) (R' : Type u_1) (S : Type u_4) (S' : Type u_3) [inst : NonAssocSemiring R]
[inst_1 : NonAssocSemiring S] [inst_2 : NonAssocSemiring R'] [inst_3 : NonAssocSemiring S'] (x y : (R × R') × S × S'),
(MulEquiv.prodProdProdComm R R' S S').toFun (x * y) =
(MulEquiv.prodProdProdComm R R' S S').toFun x *... | false |
_private.Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily.0.CategoryTheory.PreZeroHypercoverFamily.mem_precoverage_iff.match_1_1 | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P : CategoryTheory.PreZeroHypercoverFamily C} {X : C}
(motive : (R : CategoryTheory.Presieve X) → R ∈ P.precoverage.coverings X → Prop) (R : CategoryTheory.Presieve X)
(x : R ∈ P.precoverage.coverings X),
(∀ (E : CategoryTheory.PreZeroHypercover X) (... | false |
IO.FS.Mode.recOn | Init.System.IO | {motive : IO.FS.Mode → Sort u} →
(t : IO.FS.Mode) →
motive IO.FS.Mode.read →
motive IO.FS.Mode.write →
motive IO.FS.Mode.writeNew → motive IO.FS.Mode.readWrite → motive IO.FS.Mode.append → motive t | false |
Vector.flatMap_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {m : ℕ} {xs : Vector α n} {x : α} {f : α → Vector β m},
(xs.push x).flatMap f = Vector.cast ⋯ (xs.flatMap f ++ f x) | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRev.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} (f : δ → (a : α) → β a → δ) (init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRev f init b =
(Std.DHashMap.Raw.Internal.foldRevM (fun x1 x2 x3 => pure (f x1 x2 x3)) init b).run | true |
UInt8.reduceAdd | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.DSimproc | true |
LocallyConstant.desc | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_5} →
{α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace X] →
{g : α → β} → (f : X → α) → (h : LocallyConstant X β) → g ∘ f = ⇑h → Function.Injective g → LocallyConstant X α | true |
DFinsupp.filter.congr_simp | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] (p p_1 : ι → Prop),
p = p_1 →
∀ {inst_1 : DecidablePred p} [inst_2 : DecidablePred p_1] (x x_1 : Π₀ (i : ι), β i),
x = x_1 → DFinsupp.filter p x = DFinsupp.filter p_1 x_1 | true |
CategoryTheory.Lax.OplaxTrans.LaxFunctor.bicategory_leftUnitor_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{x x_1 : CategoryTheory.LaxFunctor B C} (η : x ⟶ x_1) (a : B),
(CategoryTheory.Bicategory.leftUnitor η).inv.as.app a = (CategoryTheory.Bicategory.leftUnitor (η.app a)).inv | true |
ComplexShape.TensorSigns.casesOn | Mathlib.Algebra.Homology.ComplexShapeSigns | {I : Type u_7} →
[inst : AddMonoid I] →
{c : ComplexShape I} →
{motive : c.TensorSigns → Sort u} →
(t : c.TensorSigns) →
((ε' : Multiplicative I →* ℤˣ) →
(rel_add : ∀ (p q r : I), c.Rel p q → c.Rel (p + r) (q + r)) →
(add_rel : ∀ (p q r : I), c.Rel p q → c.Rel... | false |
CategoryTheory.Subobject.ofLEMk_comp | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} {f : A ⟶ B}
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
CategoryTheory.CategoryStruct.comp (X.ofLEMk f h) f = X.arrow | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.enorm'_eq_iff_norm_eq._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (x : E), ‖x‖ₑ = ENNReal.ofReal ‖x‖ | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.tendsto_double_sum_S_act._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y | false |
ENat.toENNReal_strictMono | Mathlib.Data.Real.ENatENNReal | StrictMono ENat.toENNReal | true |
Lean.Elab.Tactic.throwOrLogError | Lean.Elab.Tactic.Basic | Lean.MessageData → Lean.Elab.Tactic.TacticM Unit | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.commute_iff._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {G : Type u_1} [inst : Group G] {g h : G}, (h ∈ Subgroup.zpowers g) = ∃ k, g ^ k = h | false |
descPochhammer_one | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R], descPochhammer R 1 = Polynomial.X | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.mk.inj | Lean.Meta.Tactic.Simp.Arith.Int.Basic | ∀ {varMap : Lean.Meta.KExprMap ℕ} {vars : Array Lean.Expr} {varMap_1 : Lean.Meta.KExprMap ℕ} {vars_1 : Array Lean.Expr},
{ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 } → varMap = varMap_1 ∧ vars = vars_1 | true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.lt_find_iff._simp_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
Set.fintypeUnion._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Set α) [inst_1 : Fintype ↑s] [inst_2 : Fintype ↑t] (x : α),
x ∈ s.toFinset ∪ t.toFinset ↔ x ∈ s ∪ t | false |
ContinuousAlternatingMap.instNormedSpace | Mathlib.Analysis.Normed.Module.Alternating.Basic | {𝕜 : Type u} →
{E : Type wE} →
{F : Type wF} →
{ι : Type v} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
... | true |
WithBot.bot_lt_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] (a : α), ⊥ < ↑a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.