name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AddCommMonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddCommMonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | true |
Disjoint.eq_bot | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b → a ⊓ b = ⊥ | true |
Std.DTreeMap.Internal.Impl.Const.some_minEntry_eq_minEntry? | 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.minEntry l he) = Std.DTreeMap.Internal.Impl.Const.minEntry? l | true |
vadd_vsub_vadd_comm | Mathlib.Algebra.AddTorsor.Basic | ∀ {G : Type u_1} {P : Type u_2} [inst : AddCommGroup G] [inst_1 : AddTorsor G P] (v₁ v₂ : G) (p₁ p₂ : P),
(v₁ +ᵥ p₁) -ᵥ (v₂ +ᵥ p₂) = v₁ - v₂ + (p₁ -ᵥ p₂) | true |
BitVec.recOn | Init.Prelude | {w : ℕ} → {motive : BitVec w → Sort u} → (t : BitVec w) → ((toFin : Fin (2 ^ w)) → motive { toFin := toFin }) → motive t | false |
LibraryNote.forgetful_inheritance | Mathlib.Algebra.Group.Defs | Batteries.Util.LibraryNote | true |
_private.Lean.Server.FileWorker.InlayHints.0.Lean.Server.FileWorker.handleInlayHintsDidChange.updateOldInlayHints | Lean.Server.FileWorker.InlayHints | Lean.Lsp.DidChangeTextDocumentParams →
Array Lean.Elab.InlayHintInfo → Lean.Server.RequestM (Array Lean.Elab.InlayHintInfo) | true |
CategoryTheory.FreeBicategory.normalizeAux.eq_def | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ {B : Type u} [inst : Quiver B] {a : B} (x x_1 : B) (x_2 : Quiver.Path a x)
(x_3 : CategoryTheory.FreeBicategory.Hom x x_1),
CategoryTheory.FreeBicategory.normalizeAux x_2 x_3 =
match x, x_1, x_2, x_3 with
| x, x_4, p, CategoryTheory.FreeBicategory.Hom.of f => p.cons f
| x, .(x), p, CategoryTheory.FreeBicategory.Hom.id .(x) => p
| x, x_4, p, f.comp g =>
CategoryTheory.FreeBicategory.normalizeAux (CategoryTheory.FreeBicategory.normalizeAux p f) g | true |
OpenPartialHomeomorph.coe_restrOpen_symm | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : Set X} (hs : IsOpen s), ↑(e.restrOpen s hs).symm = ↑e.symm | true |
Besicovitch.TauPackage.index.eq_def | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(x : Ordinal.{u}),
p.index x =
have i := x;
have Z := ⋃ j, Metric.ball (p.c (p.index ↑j)) (p.r (p.index ↑j));
have R := ⨆ b, p.r ↑b;
Classical.epsilon fun b => p.c b ∉ Z ∧ R ≤ p.τ * p.r b | true |
Topology.IsLower.mk | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_3} [t : TopologicalSpace α] [inst : Preorder α], t = Topology.lower α → Topology.IsLower α | true |
IsDomain.toIsCancelMulZero | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} {inst : Semiring α} [self : IsDomain α], IsCancelMulZero α | true |
Aesop.OrderedHashSet.noConfusion | Aesop.Util.OrderedHashSet | {P : Sort u} →
{α : Type u_1} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Aesop.OrderedHashSet α} →
{α' : Type u_1} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Aesop.OrderedHashSet α'} →
α = α' → inst ≍ inst' → inst_1 ≍ inst'_1 → t ≍ t' → Aesop.OrderedHashSet.noConfusionType P t t' | false |
Submonoid.unop_sInf | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] (S : Set (Submonoid Mᵐᵒᵖ)), (sInf S).unop = sInf (Submonoid.op ⁻¹' S) | true |
ChainComplex.mkHomAux._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(P Q : ChainComplex V ℕ)
(succ :
(n : ℕ) →
(p :
(f : P.X n ⟶ Q.X n) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 1)) ×'
CategoryTheory.CategoryStruct.comp f' (Q.d (n + 1) n) =
CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f) →
(f'' : P.X (n + 2) ⟶ Q.X (n + 2)) ×'
CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 2) (n + 1)) =
CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst)
(n : ℕ) (x : Nat.below n.succ),
CategoryTheory.CategoryStruct.comp (succ n x.1).fst (Q.d (n + 2) (n + 1)) =
CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) x.1.snd.fst | false |
Prod.Lex.casesOn | Init.WF | ∀ {α : Type u} {β : Type v} {ra : α → α → Prop} {rb : β → β → Prop}
{motive : (a a_1 : α × β) → Prod.Lex ra rb a a_1 → Prop} {a a_1 : α × β} (t : Prod.Lex ra rb a a_1),
(∀ {a₁ : α} (b₁ : β) {a₂ : α} (b₂ : β) (h : ra a₁ a₂), motive (a₁, b₁) (a₂, b₂) ⋯) →
(∀ (a : α) {b₁ b₂ : β} (h : rb b₁ b₂), motive (a, b₁) (a, b₂) ⋯) → motive a a_1 t | false |
MvPolynomial.degrees_X | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [Nontrivial R] (n : σ), (MvPolynomial.X n).degrees = {n} | true |
MeasureTheory.measurePreserving_add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Add G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddLeftInvariant] (g : G), MeasureTheory.MeasurePreserving (fun x => g + x) μ μ | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.prevAux._proof_5 | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ), off + 1 < s.utf8ByteSize → ¬off < s.utf8ByteSize → False | false |
Std.DTreeMap.Internal.Impl.contains_minKeyD | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → t.isEmpty = false → ∀ {fallback : α}, Std.DTreeMap.Internal.Impl.contains (t.minKeyD fallback) t = true | true |
RingQuot.definition._proof_1._@.Mathlib.Algebra.RingQuot.2555519587._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | ∀ (S : Type u_3) [inst : CommSemiring S] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra S A] {B : Type u_1}
[inst_3 : Semiring B] [inst_4 : Algebra S B] {s : A → A → Prop} (f' : { f // ∀ ⦃x y : A⦄, s x y → f x = f y })
⦃x y : A⦄, s x y → ↑f' x = ↑f' y | false |
_aux_Mathlib_Algebra_Order_Module_PositiveLinearMap___unexpand_PositiveLinearMap_1 | Mathlib.Algebra.Order.Module.PositiveLinearMap | Lean.PrettyPrinter.Unexpander | false |
TestFunction.mkCLM._proof_2 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace ℝ F] [inst_3 : NormedSpace 𝕜 F] [inst_4 : Algebra ℝ 𝕜] [IsScalarTower ℝ 𝕜 F],
SMulCommClass ℝ 𝕜 F | false |
Std.HashSet.Raw.getD_filter | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{f : α → Bool} {k fallback : α},
m.WF → (Std.HashSet.Raw.filter f m).getD k fallback = (Option.filter f (m.get? k)).getD fallback | true |
_private.Init.Data.Range.Polymorphic.Char.0.Char.map._proof_1 | Init.Data.Range.Polymorphic.Char | ∀ (a : Char), a.ordinal.addNat? 1 = Option.map Char.ordinal (Std.PRange.succ? a) | false |
Lean.Lsp.TextDocumentChangeRegistrationOptions.mk | Lean.Data.Lsp.TextSync | Option Lean.Lsp.DocumentSelector → Lean.Lsp.TextDocumentSyncKind → Lean.Lsp.TextDocumentChangeRegistrationOptions | true |
EckmannHilton.AddZeroClass.IsUnital | Mathlib.GroupTheory.EckmannHilton | ∀ {X : Type u} [_G : AddZeroClass X], EckmannHilton.IsUnital (fun x1 x2 => x1 + x2) 0 | true |
MulRingSeminorm.mk.injEq | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : NonAssocRing R] (toAddGroupSeminorm : AddGroupSeminorm R)
(map_one' : toAddGroupSeminorm.toFun 1 = 1)
(map_mul' : ∀ (x y : R), toAddGroupSeminorm.toFun (x * y) = toAddGroupSeminorm.toFun x * toAddGroupSeminorm.toFun y)
(toAddGroupSeminorm_1 : AddGroupSeminorm R) (map_one'_1 : toAddGroupSeminorm_1.toFun 1 = 1)
(map_mul'_1 :
∀ (x y : R), toAddGroupSeminorm_1.toFun (x * y) = toAddGroupSeminorm_1.toFun x * toAddGroupSeminorm_1.toFun y),
({ toAddGroupSeminorm := toAddGroupSeminorm, map_one' := map_one', map_mul' := map_mul' } =
{ toAddGroupSeminorm := toAddGroupSeminorm_1, map_one' := map_one'_1, map_mul' := map_mul'_1 }) =
(toAddGroupSeminorm = toAddGroupSeminorm_1) | true |
Setoid.IsPartition.ncard_eq_finsum._auto_1 | Mathlib.Data.Setoid.Partition.Card | Lean.Syntax | false |
tsub_le_self | Mathlib.Algebra.Order.Sub.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] [inst_3 : Sub α]
[OrderedSub α] {a b : α}, a - b ≤ a | true |
LaurentPolynomial.smul_eq_C_mul | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (r : R) (f : LaurentPolynomial R), r • f = LaurentPolynomial.C r * f | true |
OrderDual.instRing._proof_3 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [h : Ring R] (n : ℕ) (a : Rᵒᵈ), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | false |
CategoryTheory.Limits.HasLimitsOfShape.has_limit._autoParam | Mathlib.CategoryTheory.Limits.HasLimits | Lean.Syntax | false |
DirectSum.sigmaLcurry_apply | Mathlib.Algebra.DirectSum.Module | ∀ (R : Type u) [inst : Semiring R] {ι : Type v} {α : ι → Type u_1} {δ : (i : ι) → α i → Type w} [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → (j : α i) → AddCommMonoid (δ i j)] [inst_3 : (i : ι) → (j : α i) → Module R (δ i j)]
(f : DirectSum ((x : ι) × α x) fun i => δ i.fst i.snd) (i : ι) (j : α i),
(((DirectSum.sigmaLcurry R) f) i) j = f ⟨i, j⟩ | true |
UInt8.le_trans | Init.Data.UInt.Lemmas | ∀ {a b c : UInt8}, a ≤ b → b ≤ c → a ≤ c | true |
ValuationRing.commGroupWithZero._proof_3 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_1) [inst : CommRing A] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra A K]
(a : ValuationRing.ValueGroup A K), a * 1 = a | false |
LinearEquiv.baseChange_one | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_1) (A : Type u_2) (M : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M], LinearEquiv.baseChange R A M M 1 = 1 | true |
SSet.Truncated.Edge.id_tensor_id | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ {X Y : SSet.Truncated 2}
(x : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge.tensor._proof_1 }))
(y : Y.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge.tensor._proof_1 })),
(SSet.Truncated.Edge.id x).tensor (SSet.Truncated.Edge.id y) = SSet.Truncated.Edge.id (x, y) | true |
Sum.Lex.denselyOrdered_of_noMinOrder | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [DenselyOrdered α] [DenselyOrdered β] [NoMinOrder β],
DenselyOrdered (Lex (α ⊕ β)) | true |
ProjectiveSpectrum.not_irrelevant_le | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] (self : ProjectiveSpectrum 𝒜), ¬HomogeneousIdeal.irrelevant 𝒜 ≤ self.asHomogeneousIdeal | true |
Seminorm.absorbent_closedBall_zero | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(p : Seminorm 𝕜 E) {r : ℝ}, 0 < r → Absorbent 𝕜 (p.closedBall 0 r) | true |
CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit_inv | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f}
{cc' : CategoryTheory.Limits.CokernelCofork f'} (hf : CategoryTheory.Limits.IsColimit cc)
(hf' : CategoryTheory.Limits.IsColimit cc') (φ : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f'),
(CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit hf hf' φ).inv =
CategoryTheory.Limits.CokernelCofork.mapOfIsColimit hf' cc φ.inv | true |
Std.Iter.anyM_filterMapM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m]
[inst_3 : MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] {it : Std.Iter β} {f : β → m (Option β')}
{p : β' → m (ULift.{w, 0} Bool)},
Std.IterM.anyM p (Std.Iter.filterMapM f it) =
Std.IterM.anyM
(fun x => do
let __do_lift ← f x
match __do_lift with
| some fx => p fx
| none => pure { down := false })
(Std.Iter.mapM pure it) | true |
List.mapIdxMAux'_eq_mapIdxMGo | Mathlib.Data.List.Indexes | ∀ {m : Type u → Type v} [inst : Monad m] [LawfulMonad m] {α : Type u_1} (f : ℕ → α → m PUnit.{u + 1}) (as : List α)
(arr : Array PUnit.{u + 1}), List.mapIdxMAux' f arr.size as = List.mapIdxM.go f as arr *> pure PUnit.unit | true |
AlgEquiv.funUnique_apply | Mathlib.Algebra.Algebra.Pi | ∀ {R : Type u_3} {ι : Type u_4} [inst : CommSemiring R] (S : Type u_8) [inst_1 : Semiring S] [inst_2 : Algebra R S]
[inst_3 : Unique ι] (x : ι → S), (AlgEquiv.funUnique R ι S) x = (Equiv.funUnique ι S) x | true |
PiTensorProduct.map_pow | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (f : (i : ι) → s i →ₗ[R] s i) (n : ℕ),
PiTensorProduct.map (f ^ n) = PiTensorProduct.map f ^ n | true |
Std.Time.instDecidableEqPlainDateTime.decEq | Std.Time.DateTime.PlainDateTime | (x x_1 : Std.Time.PlainDateTime) → Decidable (x = x_1) | true |
AddOreLocalization.sub_eq_zero | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {s : ↥S},
↑s -ₒ s = 0 | true |
Lean.instInhabitedRBMap | Lean.Data.RBMap | (α : Type u) → (β : Type v) → (cmp : α → α → Ordering) → Inhabited (Lean.RBMap α β cmp) | true |
Measurable.inf | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {f g : α → M} [inst_1 : Min M]
[MeasurableInf₂ M], Measurable f → Measurable g → Measurable fun a => f a ⊓ g a | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_inter_eq_size_right._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Fin.sum_univ_eight | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : Fin 8 → M), ∑ i, f i = f 0 + f 1 + f 2 + f 3 + f 4 + f 5 + f 6 + f 7 | true |
Matrix.sum_row_of_mem_rowStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {M : Matrix n n R},
M ∈ Matrix.rowStochastic R n → ∀ (i : n), ∑ j, M i j = 1 | true |
IsLocalMin.hasFDerivAt_eq_zero | Mathlib.Analysis.Calculus.LocalExtr.Basic | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {f' : StrongDual ℝ E} {a : E},
IsLocalMin f a → HasFDerivAt f f' a → f' = 0 | true |
instProperSpaceSubtypeMemSubmoduleOfCompleteSpaceOfLocallyCompactSpace | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] [LocallyCompactSpace E] (S : Submodule 𝕜 E), ProperSpace ↥S | true |
Lean.bignumToJson | Lean.Data.Json.FromToJson.Basic | ℕ → Lean.Json | true |
Bool.cond_else_not_self | Init.Data.Bool | ∀ (c b : Bool), (bif c then b else !c) = (!c || b) | true |
FiniteMultiplicity.not_dvd_of_one_right | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a : α}, FiniteMultiplicity a 1 → ¬a ∣ 1 | true |
PiTensorProduct.liftEquiv._proof_3 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {ι : Type u_3} [inst : Fintype ι] (𝕜 : Type u_4) [inst_1 : NontriviallyNormedField 𝕜] (E : ι → Type u_1)
[inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)] (F : Type u_2)
[inst_4 : SeminormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F] (f : ContinuousMultilinearMap 𝕜 E F),
(fun l => (PiTensorProduct.lift.symm ↑l).mkContinuous ‖l‖ ⋯)
((fun f => (PiTensorProduct.lift f.toMultilinearMap).mkContinuous ‖f‖ ⋯) f) =
f | false |
_private.Lean.Util.CollectMVars.0.Lean.CollectMVars.main._sparseCasesOn_1 | Lean.Util.CollectMVars | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
(Nat.hasNotBit 3556 t.ctorIdx → motive t) → motive t | false |
String.push_inj | Init.Data.String.Lemmas.Basic | ∀ {s : String} {c : Char} {t : String} {d : Char}, s.push c = t.push d ↔ s = t ∧ c = d | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitCases.match_13 | Lean.Compiler.LCNF.ToLCNF | (motive : Option (CasesAltInfo × Subarray CasesAltInfo) → Sort u_1) →
(x : Option (CasesAltInfo × Subarray CasesAltInfo)) →
(Unit → motive none) →
((numParams : CasesAltInfo) → (s' : Subarray CasesAltInfo) → motive (some (numParams, s'))) → motive x | false |
Lean.Compiler.InlineAttributeKind.macroInline.sizeOf_spec | Lean.Compiler.InlineAttrs | sizeOf Lean.Compiler.InlineAttributeKind.macroInline = 1 | true |
_private.Lean.Language.Lean.0.Lean.Language.Lean.process.parseHeader.match_5 | Lean.Language.Lean | (motive : Option Lean.Language.Lean.CommandParsedSnapshot → Sort u_1) →
(__do_lift : Option Lean.Language.Lean.CommandParsedSnapshot) →
((nextNextCom : Lean.Language.Lean.CommandParsedSnapshot) → motive (some nextNextCom)) →
((x : Option Lean.Language.Lean.CommandParsedSnapshot) → motive x) → motive __do_lift | false |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.io.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | ∀ {hi hi_1 : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound},
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.io hi = Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.io hi_1 →
hi = hi_1 | true |
CategoryTheory.FreeBicategory.Rel.brecOn | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B]
{motive :
{a b : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(a_1 a_2 : CategoryTheory.FreeBicategory.Hom₂ f g) → CategoryTheory.FreeBicategory.Rel a_1 a_2 → Prop}
{a b : CategoryTheory.FreeBicategory B} {f g : a ⟶ b} {a_1 a_2 : CategoryTheory.FreeBicategory.Hom₂ f g}
(t : CategoryTheory.FreeBicategory.Rel a_1 a_2),
(∀ {a b : CategoryTheory.FreeBicategory B} {f g : a ⟶ b} (a_3 a_4 : CategoryTheory.FreeBicategory.Hom₂ f g)
(t : CategoryTheory.FreeBicategory.Rel a_3 a_4), CategoryTheory.FreeBicategory.Rel.below t → motive a_3 a_4 t) →
motive a_1 a_2 t | true |
Bool.cond_true_right | Init.Data.Bool | ∀ (c t : Bool), (bif c then t else true) = (!c || t) | true |
_private.Mathlib.Order.Bounds.Image.0.bddAbove_prod.match_1_1 | Mathlib.Order.Bounds.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set (α × β)} (motive : BddAbove s → Prop)
(x : BddAbove s), (∀ (p : α × β) (hp : p ∈ upperBounds s), motive ⋯) → motive x | false |
NormedAddGroupHom.Equalizer.liftEquiv_apply | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} {V₁ : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (φ : { φ // f.comp φ = g.comp φ }),
NormedAddGroupHom.Equalizer.liftEquiv φ = NormedAddGroupHom.Equalizer.lift ↑φ ⋯ | true |
instCanLiftAddUnitsValIsAddUnit | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M], CanLift M (AddUnits M) AddUnits.val IsAddUnit | true |
_private.Mathlib.Analysis.Complex.LocallyUniformLimit.0.TendstoLocallyUniformlyOn.deriv._simp_1_1 | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ {α : Type u} {p : α → Prop}, (∀ᶠ (x : α) in ⊥, p x) = True | false |
_private.Lean.Compiler.LCNF.Simp.DiscrM.0.Lean.Compiler.LCNF.Simp.getIndInfo?._sparseCasesOn_4 | Lean.Compiler.LCNF.Simp.DiscrM | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Functor.sheafPushforwardContinuousComp_inv_app_hom_app | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) (A : Type u) [inst_3 : CategoryTheory.Category.{t, u} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D)
(L : CategoryTheory.GrothendieckTopology E) [inst_4 : F.IsContinuous J K] [inst_5 : G.IsContinuous K L]
(X : CategoryTheory.Sheaf L A) (X_1 : Cᵒᵖ),
((F.sheafPushforwardContinuousComp G A J K L).inv.app X).hom.app X_1 =
CategoryTheory.CategoryStruct.id (X.obj.obj (Opposite.op (G.obj (F.obj (Opposite.unop X_1))))) | true |
AlgebraicClosure.Monics.splits_finsetProd | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ {k : Type u} [inst : Field k] {s : Finset (AlgebraicClosure.Monics k)} {f : AlgebraicClosure.Monics k},
f ∈ s → (Polynomial.map (algebraMap k (∏ f ∈ s, ↑f).SplittingField) ↑f).Splits | true |
_private.Mathlib.Topology.Semicontinuity.Basic.0.upperSemicontinuousAt_inv_iff._simp_1_2 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {x : α},
UpperSemicontinuousAt f x = UpperSemicontinuousWithinAt f Set.univ x | false |
Mathlib.PrintSorries.State.sorryMsgs | Mathlib.Util.PrintSorries | Mathlib.PrintSorries.State → Array Lean.MessageData | true |
Orientation.rotation_eq_self_iff | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x : V) (θ : Real.Angle), (o.rotation θ) x = x ↔ x = 0 ∨ θ = 0 | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushArgsTodo._sunfold | Lean.Meta.Sym.Simp.DiscrTree | Array Lean.Expr → Lean.Expr → Array Lean.Expr | false |
IsNilpotent.smul | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : MonoidWithZero R] [inst_1 : MonoidWithZero S] [inst_2 : MulActionWithZero R S]
[SMulCommClass R S S] [IsScalarTower R S S] {a : S}, IsNilpotent a → ∀ (t : R), IsNilpotent (t • a) | true |
continuousSubgroup.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Group β]
[inst_3 : IsTopologicalGroup β], continuousSubgroup α β = { toSubmonoid := continuousSubmonoid α β, inv_mem' := ⋯ } | true |
RegularExpression.noConfusionType | Mathlib.Computability.RegularExpressions | Sort u_1 → {α : Type u} → RegularExpression α → {α' : Type u} → RegularExpression α' → Sort u_1 | false |
IsDedekindDomain.HeightOneSpectrum.instFaithfulSMulSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers_1 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
FaithfulSMul (↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v))
(IsDedekindDomain.HeightOneSpectrum.adicCompletion K v) | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.Measure.withDensity.instSFinite._simp_1 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → ∀ (f : α → ENNReal), (μ.restrict s).withDensity f = (μ.withDensity f).restrict s | false |
not_or_of_imp | Mathlib.Logic.Basic | ∀ {a b : Prop}, (a → b) → ¬a ∨ b | true |
MonoidAlgebra.domCongr_refl | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Monoid M], MonoidAlgebra.domCongr R A (MulEquiv.refl M) = AlgEquiv.refl | true |
Cardinal.ofENat_le_nat | Mathlib.SetTheory.Cardinal.ENat | ∀ {m : ℕ∞} {n : ℕ}, ↑m ≤ ↑n ↔ m ≤ ↑n | true |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_comp_equiv._simp_1_3 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | false |
Submodule.inf_orthogonal | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K₁ K₂ : Submodule 𝕜 E), K₁ᗮ ⊓ K₂ᗮ = (K₁ ⊔ K₂)ᗮ | true |
Ordinal.nfp_monotone | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ {f : Ordinal.{u} → Ordinal.{u}}, Monotone f → Monotone (Ordinal.nfp f) | true |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.not_continuousAt_deriv_qaryEntropy_zero._simp_1_2 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {α : Type u_1} [inst : LE α] [NoTopOrder α] (a : α), IsTop a = False | false |
CircleDeg1Lift.map_lt_of_translationNumber_lt_nat | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) {n : ℕ}, f.translationNumber < ↑n → ∀ (x : ℝ), f x < x + ↑n | true |
Polynomial.support_ofFinsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : AddMonoidAlgebra R ℕ), { toFinsupp := p }.support = p.support | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.isAtom_smul_finset._simp_1 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {K : ℝ} {A S : Finset G} {a : G},
Finset.IsAtom✝ K S (a • A) = Finset.IsAtom✝¹ K S A | false |
BitVec.getElem_one | Init.Data.BitVec.Lemmas | ∀ {i w : ℕ} (h : i < w), (1#w)[i] = decide (i = 0) | true |
MonoidHom.fromOpposite._proof_1 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N), f 1 = 1 | false |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.evalNf0.match_1 | Lean.Meta.Tactic.AC.Main | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc? : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc? | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.seqToCode.go.match_3.splitter | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Compiler.LCNF.ToLCNF.Element → Sort u_1) →
(x : Lean.Compiler.LCNF.ToLCNF.Element) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.jp decl)) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.fun decl)) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.let decl)) →
((p : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.unreach p)) →
((auxParam : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
(cases : Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.cases auxParam cases)) →
motive x | true |
FunctionField.FqtInfty.instField._proof_57 | Mathlib.NumberTheory.FunctionField | ∀ (Fq : Type u_1) [inst : Field Fq] [inst_1 : DecidableEq (RatFunc Fq)],
autoParam
(∀ (n : ℕ) (a : FunctionField.FqtInfty Fq),
FunctionField.FqtInfty.instField._aux_53 Fq (Int.negSucc n) a =
(FunctionField.FqtInfty.instField._aux_53 Fq (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam | false |
_private.Mathlib.GroupTheory.GroupAction.Jordan.0.MulAction.IsPreprimitive.is_two_motive_of_is_motive._simp_1_3 | Mathlib.GroupTheory.GroupAction.Jordan | ∀ {α : Type u_1} {s : Set α}, (s.ncard = 1) = ∃ a, s = {a} | false |
Nat.toArray_rio_eq_singleton_append_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {xs : Array ℕ} {n a : ℕ}, (*...n).toArray = #[a] ++ xs ↔ 0 = a ∧ 0 < n ∧ (1...n).toArray = xs | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.