name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DTreeMap.Internal.Impl.entryAtIdx?.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (x size : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k v l r).entryAtIdx? x =
match compare x l.size with
| Ordering.lt => l.entryAtIdx? x
| Ordering.eq => some ⟨k, v⟩
| Ordering.gt => r.entryAtIdx? (x - l.size - ... | true |
_private.Mathlib.RingTheory.Radical.Basic.0.UniqueFactorizationMonoid.dvd_radical_iff_of_irreducible._simp_1_1 | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a b : M}, (a ∈ UniqueFactorizationMonoid.primeFactors b) = (a ∈ UniqueFactorizationMonoid.normalizedFactors b) | false |
factorThruImageSubobject_comp_imageToKernel | Mathlib.Algebra.Homology.ImageToKernel | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {A B C : V}
(f : A ⟶ B) [inst_2 : CategoryTheory.Limits.HasImage f] (g : B ⟶ C) [inst_3 : CategoryTheory.Limits.HasKernel g]
(w : CategoryTheory.CategoryStruct.comp f g = 0),
CategoryTheory.CategoryStruct.... | true |
MeasureTheory.Content.mono' | Mathlib.MeasureTheory.Measure.Content | ∀ {G : Type w} [inst : TopologicalSpace G] (self : MeasureTheory.Content G) (K₁ K₂ : TopologicalSpace.Compacts G),
↑K₁ ⊆ ↑K₂ → self.toFun K₁ ≤ self.toFun K₂ | true |
Array.back?_replicate | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {n : ℕ}, (Array.replicate n a).back? = if n = 0 then none else some a | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastSub._simp_1_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} (self : aig.Ref),
(self.gate < aig.decls.size) = True | false |
StrictMonoOn.dual_right | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictMonoOn f s → StrictAntiOn (⇑OrderDual.toDual ∘ f) s | true |
CoxeterSystem.IsReflection.conj | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W},
cs.IsReflection t → ∀ (w : W), cs.IsReflection (w * t * w⁻¹) | true |
RootPairingCat.coweight | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} → [inst : CommRing R] → RootPairingCat R → Type v | true |
Equiv.piUnique_apply | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} [inst : Unique α] (β : α → Sort u_1), ⇑(Equiv.piUnique β) = fun f => f default | true |
Aesop.RuleSetNameFilter | Aesop.RuleSet.Filter | Type | true |
_private.Mathlib.CategoryTheory.Monoidal.Grp_.0.CategoryTheory.GrpObj.eq_lift_inv_left._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.MonObj B] (f g h : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift f
(CategoryTheory.CategoryStruct.comp (Cate... | false |
SchauderBasis | Mathlib.Analysis.Normed.Module.Bases | (𝕜 : Type u_4) →
(X : Type u_5) →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup X] → [NormedSpace 𝕜 X] → Type (max (max 0 u_4) u_5) | true |
HEq.casesOn | Init.Prelude | {α : Sort u} →
{a : α} →
{motive : {β : Sort u} → (a_1 : β) → a ≍ a_1 → Sort u_1} →
{β : Sort u} → {a_1 : β} → (t : a ≍ a_1) → motive a ⋯ → motive a_1 t | false |
CategoryTheory.moduleEndLeft | Mathlib.CategoryTheory.Preadditive.Opposite | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] → {X Y : C} → Module (CategoryTheory.End X)ᵐᵒᵖ (X ⟶ Y) | true |
Real.sign_neg | Mathlib.Data.Real.Sign | ∀ {r : ℝ}, (-r).sign = -r.sign | true |
Std.Iterator.mk.noConfusion | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : outParam (Type w)} →
{P : Sort u} →
{IsPlausibleStep : Std.IterM m β → Std.IterStep (Std.IterM m β) β → Prop} →
{step : (it : Std.IterM m β) → m (Std.Shrink (Std.PlausibleIterStep (IsPlausibleStep it)))} →
{IsPlausibleStep' : Std.Ite... | false |
Std.Roo.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {pref suff : List α} {cur : α} (h : r.toList = pref ++ cur :: suff),
cu... | true |
Std.DTreeMap.Internal.Impl.Const.some_maxEntry_eq_maxEntry? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [Ord α] {l : Std.DTreeMap.Internal.Impl α fun x => β} {he : l.isEmpty = false},
some (Std.DTreeMap.Internal.Impl.Const.maxEntry l he) = Std.DTreeMap.Internal.Impl.Const.maxEntry? l | true |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Basic.0.Matrix.GeneralLinearGroup.center_eq_range_scalar._simp_1_2 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Basic | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | false |
Lean.Parser.ParserContext.resolveParserName | Lean.Parser.Extension | Lean.Parser.ParserContext → Lean.Ident → List Lean.Parser.ParserResolution | true |
Nat.cast_finsetSup'._simp_1 | Mathlib.Algebra.Order.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {s : Finset ι}
(f : ι → ℕ) (hs : s.Nonempty), (s.sup' hs fun i => ↑(f i)) = ↑(s.sup' hs f) | false |
CategoryTheory.Bimon.equivMonComonUnitIsoAppXAux | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
(M : CategoryTheory.Bimon C) →
M.X.X ≅ (((CategoryTheory.Bimon.toMonComon C).comp (CategoryTheory.Bimon.ofMonComon C)).obj M).X.X | true |
MulEquiv.withZero._proof_10 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} [inst : Group α] [inst_1 : Group β], MonoidHomClass (β ≃* α) β α | false |
CategoryTheory.Limits.IsIPC.isIso | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasProducts C}
{inst_2 : CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C} [self : CategoryTheory.Limits.IsIPC C]
(α : Type w) (I : α → Type w) [inst_3 : (i : α) → CategoryTheory.SmallCategory (I i)]
[inst_4 : ∀... | true |
BoxIntegral.Prepartition.mem_top._simp_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, (J ∈ ⊤) = (J = I) | false |
CategoryTheory.Limits.WalkingParallelPairHom._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | (a a_1 : CategoryTheory.Limits.WalkingParallelPair) → SizeOf (CategoryTheory.Limits.WalkingParallelPairHom a a_1) | false |
HahnSeries.finiteArchimedeanClassOrderIso.eq_1 | Mathlib.RingTheory.HahnSeries.Lex | ∀ (Γ : Type u_1) (R : Type u_2) [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[inst_3 : IsOrderedAddMonoid R] [inst_4 : Archimedean R] [inst_5 : Nontrivial R],
HahnSeries.finiteArchimedeanClassOrderIso Γ R =
(HahnSeries.finiteArchimedeanClassOrderIsoLex Γ R).trans (Prod.Lex.prodUniqu... | true |
CategoryTheory.Idempotents.instAddCommGroupHom._proof_4 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{P Q : CategoryTheory.Idempotents.Karoubi C} (x : P ⟶ Q), nsmulRec 0 x = 0 | false |
BitVec.adcb | Init.Data.BitVec.Bitblast | Bool → Bool → Bool → Bool × Bool | true |
Submodule.smul_bot | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A] {M : Type u_1}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [inst_6 : IsScalarTower R A M]
(I : Submodule R A), I • ⊥ = ⊥ | true |
DividedPowerAlgebra.dp_add | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {n : ℕ}
{x y : M},
DividedPowerAlgebra.dp R n (x + y) =
∑ k ∈ Finset.antidiagonal n, DividedPowerAlgebra.dp R k.1 x * DividedPowerAlgebra.dp R k.2 y | true |
Lean.Elab.Term.PatternVarDecl.mk._flat_ctor | Lean.Elab.Match | Lean.FVarId → Lean.Elab.Term.PatternVarDecl | false |
MulOpposite.instLeftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : RightCancelSemigroup α],
MulOpposite.instLeftCancelSemigroup = { toSemigroup := MulOpposite.instSemigroup, toIsLeftCancelMul := ⋯ } | true |
isUnit_of_subsingleton._simp_2 | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] [Subsingleton M] (a : M), IsUnit a = True | false |
WithTop.instMulZeroOneClass._proof_5 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroOneClass α] (a : WithTop α), 0 * a = 0 | false |
Std.TreeSet.min_erase_eq_iff_not_compare_eq_min._simp_1 | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{he : (t.erase k).isEmpty = false}, ((t.erase k).min he = t.min ⋯) = ¬cmp k (t.min ⋯) = Ordering.eq | false |
Filter.liminf_le_of_frequently_le | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {ι : Type u_4} [inst : ConditionallyCompleteLattice α] {f : Filter ι} {u : ι → α} {a : α},
(∃ᶠ (i : ι) in f, u i ≤ a) →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f u) Filter.liminf_le_of_frequently_le._auto_1 →
Filter.liminf u f ≤ a | true |
CategoryTheory.MonoidalCategory.tensor_δ | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : C × C),
CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.MonoidalCategory.tensor C) X Y =
CategoryTheory.MonoidalCategory.tensorδ X.1 X.2 Y.1 Y.2 | true |
Int.abs_le_sqrt_iff_sq_le | Mathlib.Data.Int.Order.Lemmas | ∀ {a b : ℤ}, 0 ≤ b → (|a| ≤ Int.sqrt b ↔ a ^ 2 ≤ b) | true |
Fin.rec0._proof_1 | Mathlib.Data.Fin.Basic | ∀ (i : Fin 0), ↑i < 0 | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.F''_le._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α] [AddRightMono α] [AddRightReflectLE α] (a : α) {b : α},
(a ≤ b + a) = (0 ≤ b) | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Ψ_neg._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a | false |
TensorPower.mulEquiv | Mathlib.LinearAlgebra.TensorPower.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{n m : ℕ} → TensorProduct R (TensorPower R n M) (TensorPower R m M) ≃ₗ[R] TensorPower R (n + m) M | true |
Lean.Meta.whnfImp._unsafe_rec | Lean.Meta.WHNF | Lean.Expr → Lean.MetaM Lean.Expr | false |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.withRecApps.loop._sparseCasesOn_10 | Lean.Elab.PreDefinition.WF.GuessLex | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(... | false |
CategoryTheory.coyonedaLemma._proof_3 | Mathlib.CategoryTheory.Yoneda | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : C × CategoryTheory.Functor C (Type u_2)}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.coyonedaPairing C).map f)
((fun x => (CategoryTheory.coyonedaEquiv.trans Equiv.ulift.symm).toIso) Y).hom =
CategoryTheory.Category... | false |
Prod.seminormedAddGroup | Mathlib.Analysis.Normed.Group.Constructions | {E : Type u_2} → {F : Type u_3} → [SeminormedAddGroup E] → [SeminormedAddGroup F] → SeminormedAddGroup (E × F) | true |
instOneLex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : One α] → One (Lex α) | true |
Std.DHashMap.Internal.Raw₀.isEmpty_modify | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α], (↑m).WF → ∀ {k : α} {f : β k → β k}, (↑(m.modify k f)).isEmpty = (↑m).isEmpty | true |
QuaternionAlgebra.coe | Mathlib.Algebra.Quaternion | {R : Type u_3} → {c₁ c₂ c₃ : R} → [Zero R] → R → QuaternionAlgebra R c₁ c₂ c₃ | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.emod_eq_of_lt.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : (a b : ℤ) → (∃ n, a = ↑n) → (∃ n, b = ↑n) → 0 ≤ a → a < b → 0 ≤ b → Prop) (a b : ℤ) (x : ∃ n, a = ↑n)
(x_1 : ∃ n, b = ↑n) (H1 : 0 ≤ a) (H2 : a < b) (b0 : 0 ≤ b),
(∀ (w w_1 : ℕ) (H1 : 0 ≤ ↑w) (H2 : ↑w < ↑w_1) (b0 : 0 ≤ ↑w_1), motive ↑w ↑w_1 ⋯ ⋯ H1 H2 b0) →
motive a b x x_1 H1 H2 b0 | false |
Manifold.definition._@.Mathlib.Geometry.Manifold.Riemannian.PathELength.4077471356._hygCtx._hyg.100 | Mathlib.Geometry.Manifold.Riemannian.PathELength | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type u_2} →
[inst_2 : TopologicalSpace H] →
(I : ModelWithCorners ℝ E H) →
{M : Type u_3} →
[inst_3 : TopologicalSpace M] →
[inst_4 : ChartedSpace H M] → [(x : M) → ... | false |
List.getElem_insertIdx._proof_4 | Init.Data.List.Nat.InsertIdx | ∀ {α : Type u_1} {l : List α} {x : α} {i j : ℕ}, j < (l.insertIdx i x).length → ¬j < i → ¬j = i → j - 1 < l.length | false |
Metric.unitClosedBall.instZero | Mathlib.Analysis.Normed.Field.UnitBall | {𝕜 : Type u_1} → [inst : Zero 𝕜] → [inst_1 : PseudoMetricSpace 𝕜] → Zero ↑(Metric.closedBall 0 1) | true |
Holor.unitVec.eq_1 | Mathlib.Data.Holor | ∀ {α : Type} [inst : Monoid α] [inst_1 : AddMonoid α] (d j : ℕ) (ti : HolorIndex [d]),
Holor.unitVec d j ti = if ↑ti = [j] then 1 else 0 | true |
Polynomial.trinomial.eq_1 | Mathlib.RingTheory.Polynomial.Selmer | ∀ {R : Type u_1} [inst : Semiring R] (k m n : ℕ) (u v w : R),
Polynomial.trinomial k m n u v w =
Polynomial.C u * Polynomial.X ^ k + Polynomial.C v * Polynomial.X ^ m + Polynomial.C w * Polynomial.X ^ n | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.sle_eq_slt_or_eq._simp_1_3 | Init.Data.BitVec.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | false |
AlgebraicGeometry.etale_le_weaklyEtale | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | @AlgebraicGeometry.Etale ≤ @AlgebraicGeometry.WeaklyEtale | true |
_private.Aesop.Frontend.RuleExpr.0.Aesop.Frontend.RuleConfig.validateForAdditionalRules.getPhaseAndPriority._sparseCasesOn_1 | Aesop.Frontend.RuleExpr | {motive : Aesop.BuilderName → Sort u} →
(t : Aesop.BuilderName) → motive Aesop.BuilderName.simp → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.ParametrizedAdjunction.hasLiftingProperty_iff | Mathlib.CategoryTheory.LiftingProperties.ParametrizedAdjunction | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} ... | true |
_private.Mathlib.Algebra.BigOperators.Fin.0.List.alternatingSum.match_1.eq_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {G : Type u_1} (motive : List G → Sort u_2) (h_1 : Unit → motive []) (h_2 : (g : G) → motive [g])
(h_3 : (g h : G) → (t : List G) → motive (g :: h :: t)),
(match [] with
| [] => h_1 ()
| [g] => h_2 g
| g :: h :: t => h_3 g h t) =
h_1 () | true |
Matrix.transpose_list_prod | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {α : Type u_11} [inst : CommSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m]
(l : List (Matrix m m α)), l.prod.transpose = (List.map Matrix.transpose l).reverse.prod | true |
Lean.Meta.Match.MatchEqns.rec | Lean.Meta.Match.MatchEqsExt | {motive : Lean.Meta.Match.MatchEqns → Sort u} →
((eqnNames : Array Lean.Name) →
(splitterName : Lean.Name) →
(splitterMatchInfo : Lean.Meta.MatcherInfo) →
motive { eqnNames := eqnNames, splitterName := splitterName, splitterMatchInfo := splitterMatchInfo }) →
(t : Lean.Meta.Match.MatchEqns... | false |
isConnected_Ioc | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {a b : α}, a < b → IsConnected (Set.Ioc a b) | true |
Lean.Elab.Tactic.BVDecide.Frontend.SatAtBVLogical.mk.sizeOf_spec | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | ∀ (bvExpr : Std.Tactic.BVDecide.BVLogicalExpr) (satAtAtoms : Lean.Elab.Tactic.BVDecide.Frontend.M Lean.Expr)
(expr : Lean.Expr),
sizeOf { bvExpr := bvExpr, satAtAtoms := satAtAtoms, expr := expr } = 1 + sizeOf bvExpr + sizeOf expr | true |
WittVector.wittOne.eq_1 | Mathlib.RingTheory.WittVector.Defs | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], WittVector.wittOne p = wittStructureInt p 1 | true |
_private.Mathlib.Topology.Closure.0.interior_union_isClosed_of_interior_empty.match_1_1 | Mathlib.Topology.Closure | ∀ {X : Type u_1} {s : Set X} (u : Set X) (x : X) (motive : x ∈ u \ s → Prop) (x_1 : x ∈ u \ s),
(∀ (h₁ : x ∈ u) (h₂ : x ∉ s), motive ⋯) → motive x_1 | false |
AddSubgroup.discreteTopology_iff_of_finiteIndex | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{H : AddSubgroup G} [H.FiniteIndex], DiscreteTopology ↥H ↔ DiscreteTopology G | true |
Lean.Meta.DefEqCacheKey._sizeOf_inst | Lean.Meta.Basic | SizeOf Lean.Meta.DefEqCacheKey | false |
CategoryTheory.Limits.IsLimit.isoUniqueConeMorphism | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit t ≅ (s : CategoryTheory.Limits.Cone F) → Unique (s... | true |
LinearMap.map_smul | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M] [inst_4 : Module R M₂] (fₗ : M →ₗ[R] M₂) (c : R) (x : M),
fₗ (c • x) = c • fₗ x | true |
CFC.eq_zero_of_quasispectrum_eq_zero._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
List.takeList.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (x : List α), x.takeList [] = ([], x) | true |
Lean.JsonRpc.ResponseError.noConfusionType | Lean.Data.JsonRpc | Sort u_1 → {α : Type u} → Lean.JsonRpc.ResponseError α → {α' : Type u} → Lean.JsonRpc.ResponseError α' → Sort u_1 | false |
TopCat.instIsStableUnderBaseChangePrecoverage | Mathlib.Topology.Category.TopCat.GrothendieckTopology | TopCat.precoverage.IsStableUnderBaseChange | true |
WittVector.mk'.sizeOf_spec | Mathlib.RingTheory.WittVector.Defs | ∀ {p : ℕ} {R : Type u_1} [inst : SizeOf R] (coeff : ℕ → R), sizeOf { coeff := coeff } = 1 | true |
Mathlib.Tactic.Ring.add_pos_right | Mathlib.Tactic.Ring.Common | ∀ {a₂ : ℕ} (a₁ : ℕ), 0 < a₂ → 0 < a₁ + a₂ | true |
Lean.Meta.Grind.Order.ToPropagate.rec | Lean.Meta.Tactic.Grind.Order.Types | {motive : Lean.Meta.Grind.Order.ToPropagate → Sort u} →
((c : Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId) →
(e : Lean.Expr) →
(u v : Lean.Meta.Grind.Order.NodeId) →
(k k' : Lean.Meta.Grind.Order.Weight) → motive (Lean.Meta.Grind.Order.ToPropagate.eqTrue c e u v k k')) →
((c :... | false |
PerfectRing.liftAux.eq_1 | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommSemiring K] [inst_1 : CommSemiring L]
[inst_2 : CommSemiring M] (i : K →+* L) (j : K →+* M) (p : ℕ) [inst_3 : ExpChar M p] [inst_4 : PerfectRing M p]
[inst_5 : IsPRadical i p] (x : L),
PerfectRing.liftAux i j p x = (iterateFrobeniusEquiv M p (Classical.ch... | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._proof_18 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ),
autoParam (k ≤ n) CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._auto_1 → k + 1 + 1 ≤ n + 3 | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.mod_two_pow_succ | Init.Data.BitVec.Bitblast | ∀ (x i : ℕ), x % 2 ^ (i + 1) = 2 ^ i * (x.testBit i).toNat + x % 2 ^ i | true |
LieRing.ofAssociativeRing._proof_1 | Mathlib.Algebra.Lie.OfAssociative | ∀ {A : Type u_1} [inst : Ring A] (x x_1 x_2 : A), ⁅x + x_1, x_2⁆ = ⁅x, x_2⁆ + ⁅x_1, x_2⁆ | false |
Array.countP_eq_zero._simp_1 | Init.Data.Array.Count | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.countP p xs = 0) = ∀ a ∈ xs, ¬p a = true | false |
Std.Roo.Sliceable.noConfusion | Init.Data.Slice.Notation | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{γ : Type w} →
{t : Std.Roo.Sliceable α β γ} →
{α' : Type u} →
{β' : Type v} →
{γ' : Type w} →
{t' : Std.Roo.Sliceable α' β' γ'} →
α = α' → β = β' → γ = γ' → t ≍ t' → Std.Roo.Sliceabl... | false |
Perfection.mk_comp_teichmuller' | Mathlib.RingTheory.Teichmuller | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] (I : Ideal R) [inst_2 : CharP (R ⧸ I) p]
[inst_3 : IsAdicComplete I R],
⇑(Ideal.Quotient.mk I) ∘ ⇑(Perfection.teichmuller p I) = ⇑(Perfection.coeff (R ⧸ I) p 0) | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage._proof_8 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preregular C]
[inst_2 : CategoryTheory.FinitaryExtensive C]
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type u_1))}
(hF : ∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.ma... | false |
Mathlib.Tactic.CancelDenoms.cancel_factors_eq | Mathlib.Tactic.CancelDenoms.Core | ∀ {α : Type u_1} [inst : Field α] {a b ad bd a' b' gcd : α},
ad * a = a' → bd * b = b' → ad ≠ 0 → bd ≠ 0 → gcd ≠ 0 → (a = b) = (1 / gcd * (bd * a') = 1 / gcd * (ad * b')) | true |
Lean.instToExprDeclarationRanges | Lean.Data.DeclarationRange | Lean.ToExpr Lean.DeclarationRanges | true |
Hyperreal.Infinitesimal.add | Mathlib.Analysis.Real.Hyperreal | ∀ {x y : ℝ*}, x.Infinitesimal → y.Infinitesimal → (x + y).Infinitesimal | true |
IsAddRightRegular.add_right_eq_self_iff._simp_1 | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {a b : R}, IsAddRightRegular a → (b + a = a) = (b = 0) | false |
AddCommMonCat.forget₂CreatesLimit._proof_8 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddCommMonCat)
(x : CategoryTheory.Limits.Cone F) (x_1 : ↑((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone x).1) {j j' : J}
(f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget AddMonCa... | false |
List.getElem_eq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {l : List α} {i : ℕ} (h : i < l.length), l[i] = x ↔ l[i]? = some x | true |
Lean.PrettyPrinter.Parenthesizer.checkColGe.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | true |
TwoSidedIdeal.coe_unop | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] {I : TwoSidedIdeal Rᵐᵒᵖ}, ↑I.unop = MulOpposite.op ⁻¹' ↑I | true |
mem_selfAdjointMatricesSubmodule | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} [inst : CommRing R] [inst_1 : Fintype n] (J A₁ : Matrix n n R)
[inst_2 : DecidableEq n], A₁ ∈ selfAdjointMatricesSubmodule J ↔ J.IsSelfAdjoint A₁ | true |
CategoryTheory.LaxMonoidalFunctor.Hom.hom | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F G : CategoryTheory.LaxMonoidalFunctor C D} → F.Hom G → ... | true |
Ideal.instMulActionAlgEquivElemPrimesOver._proof_2 | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_2} {B : Type u_1} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {p : Ideal A}
(K : Type u_4) (L : Type u_3) [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra A K]
[inst_6 : IsFractionRing A K] [inst_7 : Algebra B L] [inst_8 : Algebra K L] [inst_9 : Algebra A L]
[inst_10 : Is... | false |
Fin.subNat._proof_1 | Init.Data.Fin.Basic | ∀ {n : ℕ} (m : ℕ) (i : Fin (n + m)), m ≤ ↑i → ↑i - m < n | false |
Aesop.RuleStatsTotals.noConfusionType | Aesop.Stats.Basic | Sort u → Aesop.RuleStatsTotals → Aesop.RuleStatsTotals → Sort u | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.