name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CompactlyCoherentSpace.casesOn | Mathlib.Topology.Compactness.CompactlyCoherentSpace | {X : Type u_1} →
[inst : TopologicalSpace X] →
{motive : CompactlyCoherentSpace X → Sort u} →
(t : CompactlyCoherentSpace X) →
((isCoherentWith : Topology.IsCoherentWith {K | IsCompact K}) → motive ⋯) → motive t | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.snd_ne_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, 3 ≤ p.length → 1 ≤ p.length | false |
Real.sigmoid_pos | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 < x.sigmoid | true |
_private.Mathlib.Algebra.Category.MonCat.Basic.0.AddCommMonCat.Hom.mk.noConfusion | Mathlib.Algebra.Category.MonCat.Basic | {A B : AddCommMonCat} →
{P : Sort u_1} → {hom' hom'' : ↑A →+ ↑B} → { hom' := hom' } = { hom' := hom'' } → (hom' ≍ hom'' → P) → P | false |
_private.Init.Data.List.Nat.Sublist.0.List.append_sublist_of_sublist_right._proof_1_1 | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys zs : List α}, zs.length ≤ ys.length → xs.length + ys.length ≤ zs.length → ¬xs.length = 0 → False | false |
Module.AEval.restrict_equiv_mapSubmodule._proof_3 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), IsScalarTower R R ↥p | false |
Mathlib.Meta.NormNum.IsNNRat.to_eq | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : DivisionSemiring α] {n d : ℕ} {a n' d' : α},
Mathlib.Meta.NormNum.IsNNRat a n d → ↑n = n' → ↑d = d' → a = n' / d' | true |
_private.Mathlib.RingTheory.Valuation.Discrete.RankOne.0.Valuation.IsRankOneDiscrete.generator_eq_neg_exp_one_of_surjective._simp_1_4 | Mathlib.RingTheory.Valuation.Discrete.RankOne | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [Nontrivial M₀] (u : M₀ˣ), (↑u = 0) = False | false |
Lean.Meta.Grind.instInhabitedEMatchTheoremConstraint | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheoremConstraint | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Nerve.0.CategoryTheory.nerve.δ₂_two._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ¬0 ≤ 1 → False | false |
Lean.Server.Test.Runner.Client.MsgEmbed.casesOn | Lean.Server.Test.Runner | {motive_1 : Lean.Server.Test.Runner.Client.MsgEmbed → Sort u} →
(t : Lean.Server.Test.Runner.Client.MsgEmbed) →
((a : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.SubexprInfo) →
motive_1 (Lean.Server.Test.Runner.Client.MsgEmbed.expr a)) →
((a : Lean.Server.Test.Runner.Client.InteractiveGoal... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.addEmptyCaseSound._proof_1_3 | Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound | ∀ {α : Type u_2} {β : Type u_1} {σ : Type u_3} [inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β]
[inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ] [inst_2 : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(f : σ),
Std.Tactic.BVDecide.LRAT.Internal.Clause.empty ∈
Std.Tactic.BVDecide.LRAT.Internal.F... | false |
Localization.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] (S : Submonoid M), Localization S = OreLocalization S M | true |
Std.TreeMap.Raw.instCoeWFWFInner | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {t : Std.TreeMap.Raw α β cmp} → Coe t.WF t.inner.WF | true |
NNReal.iSup_div | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_2} (f : ι → NNReal) (a : NNReal), (⨆ i, f i) / a = ⨆ i, f i / a | true |
List.dropWhile_eq_self_iff | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.dropWhile p l = l ↔ ∀ (hl : 0 < l.length), ¬p l[0] = true | true |
map_mem_separableClosure_iff | Mathlib.FieldTheory.SeparableClosure | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type w} [inst_3 : Field K]
[inst_4 : Algebra F K] (i : E →ₐ[F] K) {x : E}, i x ∈ separableClosure F K ↔ x ∈ separableClosure F E | true |
UInt32.toBitVec_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt32), n.toUInt8.toBitVec = BitVec.setWidth 8 n.toBitVec | true |
Aesop.PostponedSafeRule.mk._flat_ctor | Aesop.Tree.UnsafeQueue | Aesop.SafeRule → Aesop.RuleTacOutput → Aesop.PostponedSafeRule | false |
AddGroupSeminorm.toSeminormedAddGroup._proof_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : AddGroup E] (f : AddGroupSeminorm E) (x : E), f (-x + x) = 0 | false |
CategoryTheory.instHasLimitsInd | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimits C],
CategoryTheory.Limits.HasLimits (CategoryTheory.Ind C) | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_450 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
¬[g a, g (g a)].Nodup →
∀ (w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] {g a, g (g a)}.card <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).l... | false |
Nat.choose_lt_pow | Mathlib.Data.Nat.Choose.Bounds | ∀ {n k : ℕ}, n ≠ 0 → 2 ≤ k → n.choose k < n ^ k | true |
String.Slice.SplitIterator.instIteratorIdSubslice.eq_1 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice},
String.Slice.SplitIterator.instIteratorIdSubslice =
{
IsPlausibleStep := fun x x_1 =>
... | true |
BitVec.forall_zero_iff | Init.Data.BitVec.Decidable | ∀ {P : BitVec 0 → Prop}, (∀ (v : BitVec 0), P v) ↔ P 0#0 | true |
_private.Mathlib.Topology.DiscreteSubset.0.isClosed_and_discrete_iff._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | false |
Subspace.orderIsoFiniteCodimDim._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : { W // FiniteDimensional K ↥W }ᵒᵈ), FiniteDimensional K (V ⧸ Submodule.dualCoannihilator ↑(OrderDual.ofDual W)) | false |
Lean.Compiler.LCNF.instBEqParam.beq | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Param pu → Lean.Compiler.LCNF.Param pu → Bool | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel.aux1.eq_1 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u} (l : List (Computation α)) (S : Stream'.WSeq (Computation α)),
Computation.parallel.aux1✝ (l, S) =
Computation.rmap
(fun l' =>
match Stream'.Seq.destruct S with
| none => (l', Stream'.Seq.nil)
| some (none, S') => (l', S')
| some (some c, S') => (c :: l', S'))
... | true |
ULift.seminormedRing | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_2} → [SeminormedRing α] → SeminormedRing (ULift.{u_5, u_2} α) | true |
TensorProduct.AlgebraTensorModule.congr_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : ... | true |
_private.Mathlib.RingTheory.QuasiFinite.Basic.0.Algebra.QuasiFinite.of_isIntegral_of_finiteType._simp_1_2 | Mathlib.RingTheory.QuasiFinite.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | false |
CategoryTheory.Triangulated.SpectralObject.recOn | Mathlib.CategoryTheory.Triangulated.SpectralObject | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : CategoryTheory.Preadditive C] →
... | false |
List.min?_eq_none_iff._simp_1 | Init.Data.List.MinMax | ∀ {α : Type u_1} {xs : List α} [inst : Min α], (xs.min? = none) = (xs = []) | false |
_private.Mathlib.Order.Cover.0.WithTop.coe_wcovBy_top._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Ioo ↑a ⊤ = WithTop.some '' Set.Ioi a | false |
Std.DTreeMap.Internal.Impl.balanceLErase._proof_14 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner rs k v l r).Balanced →
∀ (ls : ℕ) (lk : α) (lv : β lk),
Std.DTreeMap.Internal.delta * rs < ls →
∀ (x : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Int... | false |
_private.Mathlib.LinearAlgebra.Prod.0.Submodule.map_inl._simp_1_7 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_8}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {p : Submodule R M} {q : Submodule R M'} {x : M × M'},
(x ∈ p.prod q) = (x.1 ∈ p ∧ x.2 ∈ q) | false |
AddMonoidHom.ext_nat | Mathlib.Algebra.Group.Nat.Hom | ∀ {A : Type u_2} [inst : AddZeroClass A] {f g : ℕ →+ A}, f 1 = g 1 → f = g | true |
_private.Mathlib.Data.Option.Basic.0.Option.iget_of_mem.match_1_1 | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {a : α} (motive : (x : Option α) → a ∈ x → Prop) (x : Option α) (x_1 : a ∈ x),
(∀ (a_1 : Unit), motive (some a) ⋯) → motive x x_1 | false |
Complex.measurableEquivRealProd | Mathlib.MeasureTheory.Measure.Lebesgue.Complex | ℂ ≃ᵐ ℝ × ℝ | true |
_private.Mathlib.Data.ENat.Pow.0.ENat.epow_top._proof_1_3 | Mathlib.Data.ENat.Pow | ¬⊤ < ⊤ | false |
Polynomial.divModByMonicAux.congr_simp | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (_p _p_1 : Polynomial R),
_p = _p_1 → ∀ {q q_1 : Polynomial R} (e_q : q = q_1) (a : q.Monic), _p.divModByMonicAux a = _p_1.divModByMonicAux ⋯ | true |
List.infix_append' | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), l₂ <:+: l₁ ++ (l₂ ++ l₃) | true |
LinearMap.re_inner_adjoint_mul_self_nonneg | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E) (x : E), 0 ≤ RCLike.re (inner 𝕜 x ((LinearMap.adjoint T * T) x)) | true |
Algebra.norm_eq_of_ringEquiv | Mathlib.RingTheory.Norm.Basic | ∀ {A : Type u_8} {B : Type u_9} {C : Type u_10} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Ring C]
[inst_3 : Algebra A C] [inst_4 : Algebra B C] (e : A ≃+* B),
(algebraMap B C).comp ↑e = algebraMap A C → ∀ (x : C), e ((Algebra.norm A) x) = (Algebra.norm B) x | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processId.match_1 | Lean.Elab.PatternVar | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo val))) →
((val : Lean.ConstantInfo) → motive (some val)) → (Unit → motive none) → motive x | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_7 | Mathlib.Tactic.Linter.FindDeprecations | (motive : List String.Pos.Raw → Sort u_1) →
(x : List String.Pos.Raw) →
((a b _c : String.Pos.Raw) → motive [a, b, _c]) → ((x : List String.Pos.Raw) → motive x) → motive x | false |
_private.Lean.Meta.Transform.0.Lean.Meta.unfoldIfArgIsAppOf._sparseCasesOn_1 | Lean.Meta.Transform | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Limits.HasWideCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} → {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (J → (X ⟶ Y)) → Prop | true |
IsCompact.of_subset_of_specializes | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X},
IsCompact s → t ⊆ s → (∀ x ∈ s, ∃ y ∈ t, x ⤳ y) → IsCompact t | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.TFAE_exists_lt_isLittleO_pow.match_1_7 | Mathlib.Analysis.SpecificLimits.Normed | ∀ (f : ℕ → ℝ) (R : ℝ) (motive : (∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x) → Prop)
(x : ∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x),
(∀ (a : ℝ) (ha : a ∈ Set.Ioo 0 R) (H : f =O[Filter.atTop] fun x => a ^ x), motive ⋯) → motive x | false |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor? | Lean.Meta.Tactic.Grind.PropagateInj | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option (Lean.Expr × Lean.Expr)) | true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
Quaternion.imI_sub | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R), (a - b).imI = a.imI - b.imI | true |
LE.le.lt_or_eq_dec | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} [DecidableLE α], a ≤ b → a < b ∨ a = b | true |
Int.dvd_add_self_mul | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b + a * c ↔ a ∣ b | true |
Lean.Meta.Grind.instInhabitedEntry | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.Entry | true |
List.findIdx_singleton | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {p : α → Bool}, List.findIdx p [a] = if p a = true then 0 else 1 | true |
Pi.Lex.wellFounded | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} (r : ι → ι → Prop) {s : (i : ι) → α i → α i → Prop} [IsStrictTotalOrder ι r]
[Finite ι], (∀ (i : ι), WellFounded (s i)) → WellFounded (Pi.Lex r fun {i} => s i) | true |
LinearEquiv.conjRingEquiv._proof_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_4} {M₁ : Type u_2} {M₂ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M₁] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_6 : RingHomInvPair σ₁₂ σ₂₁] [inst_7 : RingHomInvPair σ₂₁ σ₁₂... | false |
_private.Mathlib.Topology.Instances.Irrational.0.dense_irrational._simp_1_2 | Mathlib.Topology.Instances.Irrational | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
InfiniteGalois.GaloisCoinsertionIntermediateFieldSubgroup._proof_2 | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [IsGalois k K]
(K_1 : IntermediateField k K),
((fun H => IntermediateField.fixedField H) ∘ ⇑OrderDual.toDual)
((⇑OrderDual.toDual ∘ fun E => E.fixingSubgroup) K_1) ≤
K_1 | false |
Aesop.RuleStatsTotals.compareByTotalElapsed | Aesop.Stats.Basic | Aesop.RuleStatsTotals → Aesop.RuleStatsTotals → Ordering | true |
CategoryTheory.toPresheafToSheafCompComposeAndSheafify | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Funct... | true |
Isometry.isometryEquivOnRange | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} →
{β : Type v} →
[inst : EMetricSpace α] → [inst_1 : PseudoEMetricSpace β] → {f : α → β} → Isometry f → α ≃ᵢ ↑(Set.range f) | true |
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.solve.match_3 | Lean.Meta.LevelDefEq | (motive : Lean.Level → Lean.Level → Sort u_1) →
(u v : Lean.Level) →
((mvarId : Lean.LMVarId) → (x : Lean.Level) → motive (Lean.Level.mvar mvarId) x) →
((x : Lean.Level) → (a : Lean.LMVarId) → motive x (Lean.Level.mvar a)) →
((v₁ v₂ : Lean.Level) → motive Lean.Level.zero (v₁.max v₂)) →
((a... | false |
Std.Do.SPred.entails.trans' | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, (P ⊢ₛ Q) → (P ∧ Q ⊢ₛ R) → P ⊢ₛ R | true |
Iff.not | Mathlib.Logic.Basic | ∀ {a b : Prop}, (a ↔ b) → (¬a ↔ ¬b) | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.largeSchroderSeries_eq_one_add_X_mul_largeSchroderSeries_add_X_mul_largeSchroderSeries_sq._proof_1_3 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ (n : ℕ), 0 < n → ¬n = n - 1 + 1 → False | false |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._simp_1_28 | Mathlib.Algebra.Lie.CartanExists | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
Subarray.mkSlice_roc_eq_mkSlice_rcc | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
(Std.Roc.Sliceable.mkSlice xs lo<...=hi) = Std.Rcc.Sliceable.mkSlice xs (lo + 1)...=hi | true |
AddSubmonoid.toNatSubmodule._proof_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {M : Type u_1} [inst : AddCommMonoid M],
Function.RightInverse Submodule.toAddSubmonoid fun S => { toAddSubmonoid := S, smul_mem' := ⋯ } | false |
List.findIdxNth.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (xs : List α) (n : ℕ), List.findIdxNth p xs n = List.findIdxNth.go p xs n 0 | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullback_mlieBracket._simp_1_2 | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : 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 |
Lean.IR.FnBody.set | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → Lean.IR.Arg → Lean.IR.FnBody → Lean.IR.FnBody | true |
Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n n_1 : ℕ),
(Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n = Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n_1) = (n = n_1) | true |
Real.instNormedAddCommGroupAngle._proof_30 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (x y z : Real.Angle), dist x z ≤ dist x y + dist y z | false |
Std.IterM.TerminationMeasures.Finite.mk._flat_ctor | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} → [inst : Std.Iterator α m β] → Std.IterM m β → Std.IterM.TerminationMeasures.Finite α m | false |
Lean.JsonNumber.recOn | Lean.Data.Json.Basic | {motive : Lean.JsonNumber → Sort u} →
(t : Lean.JsonNumber) →
((mantissa : ℤ) → (exponent : ℕ) → motive { mantissa := mantissa, exponent := exponent }) → motive t | false |
IsZGroup.instQuotientSubgroupOfFinite | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] [Finite G] [IsZGroup G] (H : Subgroup G) [inst_3 : H.Normal], IsZGroup (G ⧸ H) | true |
CartanMatrix.C | Mathlib.Data.Matrix.Cartan | (n : ℕ) → Matrix (Fin n) (Fin n) ℤ | true |
_private.Mathlib.Logic.Nonempty.0.exists_const_iff.match_1_1 | Mathlib.Logic.Nonempty | ∀ {α : Sort u_1} {P : Prop} (motive : (∃ x, P) → Prop) (x : ∃ x, P), (∀ (a : α) (h : P), motive ⋯) → motive x | false |
Set.disjoint_image_inl_image_inr | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {u : Set α} {v : Set β}, Disjoint (Sum.inl '' u) (Sum.inr '' v) | true |
Int8.not_xor | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, ~~~a ^^^ b = ~~~(a ^^^ b) | true |
StrictConvexOn.strictMonoOn_derivWithin | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, StrictConvexOn ℝ S f → DifferentiableOn ℝ f S → StrictMonoOn (derivWithin f S) S | true |
Lean.LeanOptionValue._sizeOf_inst | Lean.Util.LeanOptions | SizeOf Lean.LeanOptionValue | false |
CategoryTheory.AddMon.trivial_addMon_zero | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMonObj.zero = CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | true |
CategoryTheory.Bicategory.InducedBicategory.Hom₂.casesOn | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Bicategory C] →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → Sort u} →
(t : CategoryTheory.Bicatego... | false |
Std.HashMap.Raw.valuesIter | Std.Data.HashMap.Iterator | {α β : Type u} → Std.HashMap.Raw α β → Std.Iter β | true |
CategoryTheory.ObjectProperty.extensionProductIter_le_of_isTriangulatedClosed₂' | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | true |
Dioph.«term_D*_» | Mathlib.NumberTheory.Dioph | Lean.TrailingParserDescr | true |
Turing.ToPartrec.Code.brecOn.eq | Mathlib.Computability.TuringMachine.Config | ∀ {motive : Turing.ToPartrec.Code → Sort u} (t : Turing.ToPartrec.Code)
(F_1 : (t : Turing.ToPartrec.Code) → Turing.ToPartrec.Code.below t → motive t),
Turing.ToPartrec.Code.brecOn t F_1 = F_1 t (Turing.ToPartrec.Code.brecOn.go t F_1).2 | true |
RootPairing.reflectionPerm_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (self : RootPairing ι R M N) (i j : ι),
self.root j - (self.toLinearMap (self.root j)) (self.coroot i) • self.root i = self.root ((self.re... | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.noConfusion | Lean.DocString.Extension | {P : Sort u} →
{content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)} →
{priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)} →
{titleString : String} →
{title : Array (Lean.Doc.Inline Lean.ElabInline)} →
{content' : Array (Lean.Doc.Block Lean.ElabInline Lean... | false |
Std.DTreeMap.Internal.Impl.link.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hr_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced),
Std.DTreeMap.Internal.Impl.link k v Std.DTreeMap.Internal.Impl.leaf r hr_2 hr =
{ impl := (Std.DTreeMap.Internal.Impl.insertMin k v r ⋯).impl, balanced_impl... | true |
CategoryTheory.cechNerveTerminalFrom._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasFiniteProducts C] (X : C)
(n : SimplexCategoryᵒᵖ), CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => X) | false |
Module.Relations.instQuotient | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u_1} → [inst : Ring A] → (relations : Module.Relations A) → Module A relations.Quotient | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._proof_17 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_4} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type u_3} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'} {α : ι' → ι}
{p' : (j : ι') → X' j ⟶ X (α j)},
(∀ (j : ι'), CategoryTheory.CategoryStruct.comp (p' j) (f (α j)) ... | false |
NegPart.mk._flat_ctor | Mathlib.Algebra.Notation | {α : Type u_1} → (α → α) → NegPart α | false |
Orientation.oangle_sign_neg_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), (o.oangle x (-y)).sign = -(o.oangle x y).sign | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.