name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AEMeasurable.snd | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {f : α → β × γ},
AEMeasurable f μ → AEMeasurable (fun x => (f x).2) μ | true |
not_injective_infinite_finite | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_4} {β : Sort u_5} [Infinite α] [Finite β] (f : α → β), ¬Function.Injective f | true |
Lean.Parser.Command.importPath | Lean.Parser.Command | Lean.Parser.Parser | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.go._unary._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w n : ℕ} (aig : Std.Sat.AIG α) (distance : aig.RefVec n)
(curr : ℕ) (acc : aig.RefVec w),
curr < n - 1 →
∀
(this :
aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.twoPowShift aig
{ n := n, ... | false |
IsSl2Triple.HasPrimitiveVectorWith.mk._flat_ctor | Mathlib.Algebra.Lie.Sl2 | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {h e f : L} {t : IsSl2Triple h e f} {m : M} {μ : R},
m ≠ 0 → ⁅h, m⁆ = μ • m → ⁅e, m⁆ = 0 → t.HasPrimitiveVectorWith m μ | false |
toIcoDiv_ofNat_mul_add | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℕ) [inst_4 : m.AtLeastTwo],
toIcoDiv hp a (OfNat.ofNat m * p + b) = OfNat.ofNat m + toIcoDiv hp a b | true |
Stream'.Seq.BisimO._sparseCasesOn_2.else_eq | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Stream'.Seq.BisimO._sparseCasesOn_2 t some «else» = «else» h | false |
FreeAddGroup.instAddGroup._proof_8 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (n : ℕ) (a : FreeAddGroup α), zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a | false |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.NumberField.InfinitePlace._aux_Mathlib_NumberTheory_NumberField_InfinitePlace_Ramification___unexpand_MulAction_stabilizer_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | Lean.PrettyPrinter.Unexpander | false |
ZSpan.quotientEquiv_apply_mk | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (x : E),
(ZSpan.quotientEquiv b) (Submodule.Quotient.mk x)... | true |
iteratedDeriv_fun_const_zero | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜}, iteratedDeriv n (fun x => 0) x = 0 | true |
SeparationQuotient.instCommSemigroup._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : CommSemigroup M] [inst_2 : ContinuousMul M] (a b : M),
SeparationQuotient.mk (a * b) = SeparationQuotient.mk a * SeparationQuotient.mk b | false |
Bornology.isCobounded_compl_iff | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {x : Bornology α} {s : Set α}, Bornology.IsCobounded sᶜ ↔ Bornology.IsBounded s | true |
Lean.Elab.Do.ControlStack.mk.injEq | Lean.Elab.Do.Control | ∀ (description : Unit → Lean.MessageData) (m : Lean.Elab.Do.DoElabM Lean.Expr)
(stM runInBase : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr)
(restoreCont : Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont)
(description_1 : Unit → Lean.MessageData) (m_1 : Lean.Elab.Do.DoElabM Lean.Expr)
(stM... | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitQuotLift | Lean.Compiler.LCNF.ToLCNF | Lean.Expr → Lean.Compiler.LCNF.ToLCNF.M (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | true |
Batteries.Tactic.tactic_ | Batteries.Tactic.Init | Lean.ParserDescr | true |
Lean.Compiler.LCNF.Check.Pure.checkParams | Lean.Compiler.LCNF.Check | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.Check.Pure.CheckM Unit | true |
ArithmeticFunction.instAlgebra._proof_3 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_2} {S : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (x : R)
(f g : ArithmeticFunction S), x • f * g = x • (f * g) | false |
Valuation.leSubmodule_zero | Mathlib.RingTheory.Valuation.Integers | ∀ {Γ₀ : Type v} [inst : LinearOrderedCommGroupWithZero Γ₀] (K : Type u_1) [inst_1 : Field K] (v : Valuation K Γ₀),
v.leSubmodule 0 = ⊥ | true |
CategoryTheory.ReflQuiver.mk | Mathlib.Combinatorics.Quiver.ReflQuiver | {obj : Type u} → [toQuiver : Quiver obj] → ((X : obj) → X ⟶ X) → CategoryTheory.ReflQuiver obj | true |
CochainComplex.HomComplex.instAddCommGroupCochain._aux_12 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(F G : CochainComplex C ℤ) →
(n : ℤ) → CochainComplex.HomComplex.Cochain F G n → CochainComplex.HomComplex.Cochain F G n | false |
Real.arsinh_bijective | Mathlib.Analysis.SpecialFunctions.Arsinh | Function.Bijective Real.arsinh | true |
SchwartzMap.fourierMultiplierCLM_fourierMultiplierCLM_apply | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {𝕜 : Type u_2} {E : Type u_3} {F : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace ℝ E] [inst_4 : NormedSpace ℂ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℂ 𝕜 F] [inst_7 : FiniteDimensional ℝ E] [inst_8 : MeasurableSpace E] [in... | true |
AddMonoidHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : Mᵃᵒᵖ →+ Nᵃᵒᵖ) (a : M),
(AddMonoidHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a | true |
Submonoid.mk_eq_top._simp_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (toSubsemigroup : Subsemigroup M) (one_mem' : 1 ∈ toSubsemigroup.carrier),
({ toSubsemigroup := toSubsemigroup, one_mem' := one_mem' } = ⊤) = (toSubsemigroup = ⊤) | false |
Lean.Compiler.LCNF.CtorFieldInfo.object.inj | Lean.Compiler.LCNF.ToImpureType | ∀ {i : ℕ} {type : Lean.Expr} {i_1 : ℕ} {type_1 : Lean.Expr},
Lean.Compiler.LCNF.CtorFieldInfo.object i type = Lean.Compiler.LCNF.CtorFieldInfo.object i_1 type_1 →
i = i_1 ∧ type = type_1 | true |
Std.Internal.List.Const.containsKey_filterMap | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [EquivBEq α] {β : Type v} {γ : Type w} {f : α → β → Option γ} {l : List ((_ : α) × β)}
{k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k (List.filterMap (fun p => Option.map (fun x => ⟨p.fst, x⟩) (f p.fst p.snd)) l) =
if h : Std.Internal.List.contain... | true |
Lean.Parser.Command.notationItem.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter | true |
CategoryTheory.Limits.LimitPresentation.noConfusionType | Mathlib.CategoryTheory.Limits.Presentation | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
CategoryTheory.Limits.LimitPresentation J X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →... | false |
Cardinal.lt_one_iff_zero | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, c < 1 ↔ c = 0 | true |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.SpectrumRestricts.nnreal_iff_spectralRadius_le._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α] {a : α} {f : (i : ι) → κ i → α},
(⨆ i, ⨆ j, f i j ≤ a) = ∀ (i : ι) (j : κ i), f i j ≤ a | false |
IsLocalization.exist_integer_multiples_of_finite | Mathlib.RingTheory.Localization.Integer | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] {ι : Type u_4} [Finite ι] (f : ι → S),
∃ b, ∀ (i : ι), IsLocalization.IsInteger R (↑b • f i) | true |
_private.Mathlib.Data.Set.List.0.Option.getD.match_1.eq_1 | Mathlib.Data.Set.List | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : α) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match some x with
| some x => h_1 x
| none => h_2 ()) =
h_1 x | true |
CategoryTheory.Functor.exact_tfae | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {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.Abelian C]
[inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
[∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.ma... | true |
Std.IterM.step_intermediateDropWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
{it : Std.IterM m β} {P : β → Bool} {dropping : Bool},
(Std.IterM.Intermediate.dropWhile P dropping it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterSte... | true |
Filter.Germ.instAddMonoid._proof_6 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : AddMonoid M] (a : l.Germ M), a + 0 = a | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabUsingElabFnsAux._sunfold | Lean.Elab.Term.TermElabM | Lean.Elab.Term.SavedState →
Lean.Syntax →
Option Lean.Expr →
Bool → List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Term.TermElab) → Lean.Elab.TermElabM Lean.Expr | false |
Isometry.preimage_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.closedBall (f x) r = Metric.closedBall x r | true |
Lean.Lsp.FileEvent.noConfusion | Lean.Data.Lsp.Workspace | {P : Sort u} → {t t' : Lean.Lsp.FileEvent} → t = t' → Lean.Lsp.FileEvent.noConfusionType P t t' | false |
Nat.ascFactorial._sunfold | Mathlib.Data.Nat.Factorial.Basic | ℕ → ℕ → ℕ | false |
CategoryTheory.GrothendieckTopology.rec | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.GrothendieckTopology C → Sort u_1} →
((sieves : (X : C) → Set (CategoryTheory.Sieve X)) →
(top_mem' : ∀ (X : C), ⊤ ∈ sieves X) →
(pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve... | false |
Lean.Elab.Tactic.evalSimpAllArith._regBuiltin.Lean.Elab.Tactic.evalSimpAllArith_1 | Lean.Elab.Tactic.SimpArith | IO Unit | false |
UpperSet.completeLattice._proof_8 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ = (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ | false |
Std.Sat.CNF.sat_relabel | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {β : Type u_2} {r1 : β → Bool} {r2 : α → β} {f : Std.Sat.CNF α},
Std.Sat.CNF.Sat (r1 ∘ r2) f → Std.Sat.CNF.Sat r1 (Std.Sat.CNF.relabel r2 f) | true |
Fin.castLE._proof_1 | Init.Data.Fin.Basic | ∀ {n m : ℕ}, n ≤ m → ∀ (i : Fin n), ↑i < m | false |
CoheytingHom.instFunLike._proof_1 | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (f g : CoheytingHom α β),
(fun f => f.toFun) f = (fun f => f.toFun) g → f = g | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.instReprCongrArgKind.repr.match_1 | Lean.Meta.CongrTheorems | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(x : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.fixedNoParam) →
(Unit → motive Lean.Meta.CongrArgKind.eq) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → m... | false |
Set.Countable.setOf_finite | Mathlib.Data.Set.Countable | ∀ {α : Type u} [Countable α], {s | s.Finite}.Countable | true |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_1 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | false |
Lean.Exception.isInterrupt | Lean.Exception | Lean.Exception → Bool | true |
Lean.Grind.isLE | Init.Grind.Offset | ℕ → ℕ → Bool | true |
ValuationSubring.principalUnitGroupEquiv._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (x : ↥A.principalUnitGroup),
(fun x => ⟨↑(A.unitGroupMulEquiv.symm ↑x), ⋯⟩) ((fun x => ⟨A.unitGroupMulEquiv ⟨↑x, ⋯⟩, ⋯⟩) x) = x | false |
Aesop.Frontend.RuleExpr | Aesop.Frontend.RuleExpr | Type | true |
GroupTopology.instTop | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} → [inst : Group α] → Top (GroupTopology α) | true |
PartitionOfUnity.le_one | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s) (i : ι) (x : X),
(f i) x ≤ 1 | true |
ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_5 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
Continuous ⇑f | false |
MeasureTheory.MemLp.norm_rpow_div | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f : α → E},
MeasureTheory.MemLp f p μ → ∀ (q : ENNReal), MeasureTheory.MemLp (fun x => ‖f x‖ ^ q.toReal) (p / q) μ | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.map_sum._simp_1_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | (¬True) = False | false |
Std.Iter.toList_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toList = List.drop n it.toList | true |
ContDiffMapSupportedInClass.instContinuousMapClass | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (B : Type u_5) (E : outParam (Type u_6)) (F : outParam (Type u_7)) [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ E] [inst_3 : NormedSpace ℝ F] (n : outParam ℕ∞)
(K : outParam (TopologicalSpace.Compacts E)) [inst_4 : ContDiffMapSupportedInClass B E F n K],
ContinuousMapCla... | true |
tsum_setProd_singleton_left | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (b : β)
(t : Set γ) (f : β × γ → α), ∑' (x : ↑({b} ×ˢ t)), f ↑x = ∑' (c : ↑t), f (b, ↑c) | true |
Set.centralizer_centralizer_centralizer | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] (S : Set M), S.centralizer.centralizer.centralizer = S.centralizer | true |
instIsBoundedSMulSeparationQuotient | Mathlib.Topology.MetricSpace.Algebra | ∀ {α : Type u_4} {β : Type u_5} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero α]
[inst_3 : Zero β] [inst_4 : SMul α β] [inst_5 : IsBoundedSMul α β], IsBoundedSMul α (SeparationQuotient β) | true |
CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_5 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T₁ : CategoryTheory.Monad C} {X Y : T₁.Algebra}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).map f)
((fun X =>
CategoryTheory.Monad.Algebr... | false |
Std.TreeSet.Raw.get?_eq_some_getD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {a fallback : α}, a ∈ t → t.get? a = some (t.getD a fallback) | true |
CategoryTheory.AsSmall.abelian | Mathlib.CategoryTheory.Abelian.Transfer | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Abelian (CategoryTheory.AsSmall C) | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.size_eq_if_roo._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxo.HasSize α]
[Std.Rxo.LawfulHasSize α] {lo hi : α}, (Std.Rxo.HasSize.size lo hi = 0) = ¬lo < hi | false |
Finset.truncatedInf_union | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeInf α] {s t : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : BoundedOrder α]
[inst_3 : DecidableEq α],
a ∈ upperClosure ↑s → a ∈ upperClosure ↑t → (s ∪ t).truncatedInf a = s.truncatedInf a ⊓ t.truncatedInf a | true |
GenContFract.succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [inst : DivisionRing K],
GenContFract.convs'Aux s (n + 2) = GenContFract.convs'Aux (GenContFract.squashSeq s n) (n + 1) | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic | Lean.Server.Completion.CompletionCollectors | Lean.Name → Lean.Name → Bool → Bool | true |
UniformSpace.Completion.instNormedRing._proof_15 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : SeminormedRing A] (n : ℕ) (x : UniformSpace.Completion A),
Semiring.npow (n + 1) x = Semiring.npow n x * x | false |
ByteArray.extract_eq_extract_iff_getElem | Init.Data.ByteArray.Lemmas | ∀ {as bs : ByteArray} {i j len : ℕ} (hi : i + len ≤ as.size) (hj : j + len ≤ bs.size),
as.extract i (i + len) = bs.extract j (j + len) ↔ ∀ (k : ℕ) (hk : k < len), as[i + k] = bs[j + k] | true |
Std.Tactic.BVDecide.BVBinPred.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {w : ℕ} → Std.Tactic.BVDecide.BVBinPred → BitVec w → BitVec w → Bool | true |
expandLemma | Mathlib.Tactic.Lemma | Lean.Macro | true |
ByteArray.toList.loop._unary.eq_def | Init.Data.ByteArray.Basic | ∀ (bs : ByteArray) (_x : (_ : ℕ) ×' List UInt8),
ByteArray.toList.loop._unary bs _x =
PSigma.casesOn _x fun i r =>
if i < bs.size then ByteArray.toList.loop._unary bs ⟨i + 1, bs.get! i :: r⟩ else r.reverse | false |
TwoUniqueSums.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_2} (G : ι → Type u_1) [inst : (i : ι) → Add (G i)] [∀ (i : ι), TwoUniqueSums (G i)],
TwoUniqueSums ((i : ι) → G i) | true |
EuclideanGeometry.Sphere.IsExtTangentAt.mem_left | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s₁ s₂ : EuclideanGeometry.Sphere P} {p : P}, s₁.IsExtTangentAt s₂ p → p ∈ s₁ | true |
Qq.Impl.isIrrefutablePattern | Qq.Match | Lean.Term → Bool | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated.0.MeasurableSpace.CountablySeparated.mono._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α],
MeasurableSpace.CountablySeparated α = HasCountableSeparatingOn α MeasurableSet Set.univ | false |
Int.getElem!_toArray_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, (m<...n).toArray[i]! = if i < (n - (m + 1)).toNat then m + 1 + ↑i else 0 | true |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_1 | Init.Data.String.FindPos | ∀ (s : String.Slice), ∀ offset ≤ s.rawEndPos, ¬String.Pos.Raw.IsValidForSlice s offset → offset < s.rawEndPos | false |
Subrepresentation.mk._flat_ctor | Mathlib.RepresentationTheory.Subrepresentation | {A : Type u_1} →
{G : Type u_2} →
{W : Type u_3} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid W] →
[inst_3 : Module A W] →
{ρ : Representation A G W} →
(toSubmodule : Submodule A W) →
(∀ (g : G) ⦃v : W⦄, v... | false |
Lean.VersoModuleDocs.Snippet.mk.injEq | Lean.DocString.Extension | ∀ (text : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections : Array (ℕ × Lean.DeclarationRange × Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty))
(declarationRange : Lean.DeclarationRange) (text_1 : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections_1 : Array (ℕ × Lean.Declaration... | true |
Mathlib.Tactic.DepRewrite.instDecidableLECastMode._proof_1 | Mathlib.Tactic.DepRewrite | ∀ (a b : Mathlib.Tactic.DepRewrite.CastMode), a.toNat.ble b.toNat = true → a.toNat ≤ b.toNat | false |
Aesop.ScriptGenerated.perfect | Aesop.Stats.Basic | Aesop.ScriptGenerated → Bool | true |
Filter.liminf_bot | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : β → α), Filter.liminf f ⊥ = ⊤ | true |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.LocallyCompactSpace.of_hasBasis.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_2} {ι : X → Type u_1} {p : (x : X) → ι x → Prop} {s : (x : X) → ι x → Set X} (x : X) (_t : Set X)
(motive : (∃ i, p x i ∧ s x i ⊆ _t) → Prop) (x_1 : ∃ i, p x i ∧ s x i ⊆ _t),
(∀ (i : ι x) (hp : p x i) (ht : s x i ⊆ _t), motive ⋯) → motive x_1 | false |
Lean.Grind.toInt_bitVec | Init.GrindInstances.ToInt | ∀ {v : ℕ} (x : BitVec v), ↑x = ↑x.toNat | true |
Int.natAbs_dvd_natAbs._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ {a b : ℤ}, (a.natAbs ∣ b.natAbs) = (a ∣ b) | false |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._proof_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), n + m = 0 → m = -n | false |
ModelWithCorners.continuousOn_symm | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {s : Set E},
ContinuousOn (↑I.symm) s | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | false |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.quotientInfEquivProdNormalizerQuotient._simp_4 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, (QuotientGroup.leftRel s) x y = (x⁻¹ * y ∈ s) | false |
AddOpposite.instRightCancelSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [RightCancelSemigroup α] → RightCancelSemigroup αᵃᵒᵖ | true |
Vector.toArray_reverse | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), xs.reverse.toArray = xs.toArray.reverse | true |
Lean.Elab.FieldInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} → {t t' : Lean.Elab.FieldInfo} → t = t' → Lean.Elab.FieldInfo.noConfusionType P t t' | false |
_private.Mathlib.Topology.Order.LowerUpperTopology.0.Topology.IsLower.isTopologicalSpace_basis._simp_1_6 | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processExplicitArg._sparseCasesOn_1 | Lean.Elab.App | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exists_closedBall_covering_tsum_measure_le._simp_1_16 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
_private.Mathlib.Data.List.Sym.0.List.Nodup.sym2._simp_1_8 | Mathlib.Data.List.Sym | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.