name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Lsp.CreateFile.Options.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.CreateFile.Options → Sort u} →
(t : Lean.Lsp.CreateFile.Options) →
((overwrite ignoreIfExists : Bool) → motive { overwrite := overwrite, ignoreIfExists := ignoreIfExists }) → motive t | false |
Subsemigroup.coe_equivMapOfInjective_apply | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup M) (f : M →ₙ* N)
(hf : Function.Injective ⇑f) (x : ↥S), ↑((S.equivMapOfInjective f hf) x) = f ↑x | true |
CategoryTheory.bicategoricalIsoComp | Mathlib.Tactic.CategoryTheory.BicategoricalComp | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} → {f g h i : a ⟶ b} → [CategoryTheory.BicategoricalCoherence g h] → (f ≅ g) → (h ≅ i) → (f ≅ i) | true |
SchwartzMap.bilinLeftCLM._proof_13 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G], SMulCommClass ℝ ℝ G | false |
Std.TreeMap.Equiv.keyAtIdx_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {i : ℕ}
{h' : i < t₁.size} (h : t₁.Equiv t₂), t₁.keyAtIdx i h' = t₂.keyAtIdx i ⋯ | true |
_private.Mathlib.LinearAlgebra.SpecialLinearGroup.0.SpecialLinearGroup.centerEquivRootsOfUnity_invFun._simp_4 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] [Module.Free R V]
[Module.Finite R V] {g : SpecialLinearGroup R V},
(g ∈ Subgroup.center (SpecialLinearGroup R V)) = ∃ r, r ^ Module.finrank R V = 1 ∧ ↑↑g = r • LinearMap.id | false |
IndepMatroid.matroid_indep_iff._simp_1 | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} {M : IndepMatroid α} {I : Set α}, M.matroid.Indep I = M.Indep I | false |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.testBit.match_1.eq_2 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive PosNum.one 0) (h_2 : (x : ℕ) → motive PosNum.one x)
(h_3 : (a : PosNum) → motive a.bit0 0) (h_4 : (p : PosNum) → (n : ℕ) → motive p.bit0 n.succ)
(h_5 : (a : PosNum) → motive a.bit1 0) (h_6 : (p : PosNum) → (n : ℕ) → motive p.bit1 n.succ),
(x = 0 → Fa... | true |
Real.casesOn | Mathlib.Data.Real.Basic | {motive : ℝ → Sort u} → (t : ℝ) → ((cauchy : CauSeq.Completion.Cauchy abs) → motive { cauchy := cauchy }) → motive t | false |
CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_app_hom_assoc | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K) {Z : C}... | true |
CategoryTheory.MonoidalCategory.tensorRightTensor._proof_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
{Z Z' : C} (f : Z ⟶ Z'),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensorRight (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).map f)
((fun Z => (Catego... | false |
MeasureTheory.Measure.withDensityᵥ._proof_2 | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_2} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) (f : α → E),
MeasureTheory.Integrable f μ →
∀ (s : ℕ → Set α),
(∀ (i : ℕ), MeasurableSet (s i)) →
Pairwise (Function.onFun Disjoint s) →
HasSum (... | false |
Finsupp.mapDomain_support_of_injective | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : DecidableEq β] {f : α → β},
Function.Injective f → ∀ (s : α →₀ M), (Finsupp.mapDomain f s).support = Finset.image f s.support | true |
Fin.dfoldlM_zero | Batteries.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {α : Fin (0 + 1) → Type u_1} [inst : Monad m]
(f : (i : Fin 0) → α i.castSucc → m (α i.succ)) (x : α 0), Fin.dfoldlM 0 α f x = pure x | true |
HasProdLocallyUniformlyOn.mono | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β] {t : Set β},
HasProdLocallyUniformlyOn f g t → s ⊆ t → HasProdLocallyUniformlyOn f g s | true |
AlgEquiv.uniqueProd_apply | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Unique B] (self : B × A), AlgEquiv.uniqueProd self = self.2 | true |
Finset.card_le_card_of_forall_subsingleton | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {t : Finset β},
(∀ a ∈ s, ∃ b ∈ t, r a b) → (∀ b ∈ t, {a | a ∈ s ∧ r a b}.Subsingleton) → s.card ≤ t.card | true |
Affine.Triangle.prod_div_one_sub_eq_one_of_mem_line_point_lineMap | Mathlib.LinearAlgebra.AffineSpace.Ceva | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {t : Affine.Triangle k P} {r : Fin 3 → k},
(∀ (i : Fin 3), r i ≠ 0) →
∀ {p' : P},
(∀ (i : Fin 3), p' ∈ affineSpan k {t.points i, (AffineMap.lineMap (t.points (i + 1)) (t... | true |
Lean.FromJson.ctorIdx | Lean.Data.Json.FromToJson.Basic | {α : Type u} → Lean.FromJson α → ℕ | false |
Finsupp.instAddCommGroup._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddCommGroup G] (a b : ι →₀ G), a + b = b + a | false |
Lean.Elab.Tactic.GuardExpr.MatchKind.syntactic.elim | Lean.Elab.Tactic.Guard | {motive : Lean.Elab.Tactic.GuardExpr.MatchKind → Sort u} →
(t : Lean.Elab.Tactic.GuardExpr.MatchKind) →
t.ctorIdx = 0 → motive Lean.Elab.Tactic.GuardExpr.MatchKind.syntactic → motive t | false |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.ofExistsUnique._simp_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} {ι : Type u_3} [inst : DistribLattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α},
s.SupIndep f = (↑s).PairwiseDisjoint f | false |
UniformEquiv.coe_prodCongr | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β]
[inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ), ⇑(h₁.prodCongr h₂) = Prod.map ⇑h₁ ⇑h₂ | true |
AddMonoidHom.toAddEquiv.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f f_1 : M →+ N) (e_f : f = f_1)
(g g_1 : N →+ M) (e_g : g = g_1) (h₁ : g.comp f = AddMonoidHom.id M) (h₂ : f.comp g = AddMonoidHom.id N),
f.toAddEquiv g h₁ h₂ = f_1.toAddEquiv g_1 ⋯ ⋯ | true |
Lean.Meta.Grind.Arith.Linear.EqCnstr.collectDecVars._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | Lean.Meta.Grind.Arith.Linear.EqCnstr → Lean.Meta.Grind.Arith.CollectDecVarsM Unit | false |
Std.Time.Nanosecond.instLEOffset._aux_1 | Std.Time.Time.Unit.Nanosecond | Std.Time.Nanosecond.Offset → Std.Time.Nanosecond.Offset → Prop | false |
Finsupp.equivFunOnFinite_single | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : DecidableEq α] [inst_2 : Finite α] (x : α) (m : M),
(Finsupp.equivFunOnFinite fun₀ | x => m) = Pi.single x m | true |
CategoryTheory.Functor.ranCounit._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{u_2, u_3} H]
[inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasRightKanExtension F] {F₁ F₂ : CategoryThe... | false |
CategoryTheory.ShortComplex.SnakeInput.L₀'._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₁.f S.L₁.g = CategoryTheory.CategoryStruct.comp 0 S.v₀₁.τ₃ | false |
AddSubgroup.instMeasurableVAdd | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : MeasurableSpace α] [inst_2 : AddGroup G]
[inst_3 : AddAction G α] [MeasurableVAdd G α] (s : AddSubgroup G), MeasurableVAdd (↥s) α | true |
Complex.ofReal_exp._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), Complex.exp ↑x = ↑(Real.exp x) | false |
ContravariantClass.mk._flat_ctor | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop}, Contravariant M N μ r → ContravariantClass M N μ r | false |
Lean.Elab.Tactic.evalWithAnnotateState._regBuiltin.Lean.Elab.Tactic.evalWithAnnotateState_1 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | false |
SubmonoidClass.coe_multiset_prod | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {B : Type u_3} {S : B} {M : Type u_4} [inst : CommMonoid M] [inst_1 : SetLike B M] [inst_2 : SubmonoidClass B M]
(m : Multiset ↥S), ↑m.prod = (Multiset.map Subtype.val m).prod | true |
MeasureTheory.measure_biUnion_le | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {ι : Type u_2} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α]
{I : Set ι} (μ : F), I.Countable → ∀ (s : ι → Set α), μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i) | true |
instBooleanAlgebraSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_15 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (x x_1 : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }), x_1 ⊔ xᶜ = x_1 ⊔ xᶜ | false |
Bool.eq_true_of_true_le | Init.Data.Bool | ∀ {x : Bool}, true ≤ x → x = true | true |
Lean.Grind.AC.Seq.isVar | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq → Bool | true |
CochainComplex.HomComplex.Cochain.toSingleMk_v_eq_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ X) {n : ℤ}
(h : p + n = q) (p' q' : ℤ) (hpq' : p' + n = q'),
p' ≠ p → (CochainComplex.HomComplex.Cochain.toSingl... | true |
List.extract_eq_drop_take | Init.Data.List.Basic | ∀ {α : Type u_1} {l : List α} {start stop : ℕ}, l.extract start stop = List.take (stop - start) (List.drop start l) | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Basic.0.Std.Tactic.BVDecide.BVExpr.toString.match_1.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) (w idx : ℕ)
(h_1 : (w idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var idx))
(h_2 : (w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val))
(h_3 :
(len w start : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) → motive le... | true |
Manifold.wrapped._@.Mathlib.Geometry.Manifold.Riemannian.PathELength.2732887573._hygCtx._hyg.75 | Mathlib.Geometry.Manifold.Riemannian.PathELength | Subtype (Eq @Manifold.definition✝) | false |
FirstOrder.Language.Embedding.substructureEquivMap.match_3 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Embedding M N) (s : L.Substructure M) (motive : ↥(FirstOrder.Language.Substructure.map f.toHom s) → Prop)
(x : ↥(FirstOrder.Language.Substructure.map f.toHom s)),
(∀ (val : N) (hn : val ∈ FirstOrder.La... | false |
Std.ExtHashMap.getKey_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → ∀ {h : k' ∈ m.insertManyIfNewUnit l}, (m.insertManyIfNewUnit l).getK... | true |
Polynomial.Separable.of_mul_right | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] {f g : Polynomial R}, (f * g).Separable → g.Separable | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapM.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {β β' : Type u_1} →
{n : Type u_1 → Type u_2} →
{f : β → n (Option β')} →
[inst : MonadAttach n] →
(out : β) →
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) →
(__do_lift : Subtype (MonadAttach.CanReturn (f out))) →
((hf : MonadAttach.CanReturn (f o... | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon._proof_2 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C]
{X Y Z : CategoryTheory.LaxBraidedFunctor (CategoryTheory.Discrete PUnit.{u_1 + 1}) C} (f : X ⟶ Y) (g : Y ⟶ Z),
((CategoryTheory.Functor.mapCommMonFunctor (Catego... | false |
Lean.CollectAxioms.State.axioms | Lean.Util.CollectAxioms | Lean.CollectAxioms.State → Array Lean.Name | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
SemidirectProduct.card | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N},
Nat.card (N ⋊[φ] G) = Nat.card N * Nat.card G | true |
_private.Mathlib.Analysis.Normed.Module.RCLike.Real.0.closure_ball._simp_1_1 | Mathlib.Analysis.Normed.Module.RCLike.Real | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | false |
Invertible.algebraMapOfInvertibleAlgebraMap._proof_2 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₗ[R] B),
f 1 = 1 → ∀ {r : R} (h : Invertible ((algebraMap R A) r)), (algebraMap R B) r * f ⅟((algebraMap R A) r) = 1 | false |
NNReal.coe_add._simp_1 | Mathlib.Data.NNReal.Defs | ∀ (r₁ r₂ : NNReal), ↑r₁ + ↑r₂ = ↑(r₁ + r₂) | false |
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_2 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} {stop start : ℕ}, start - stop = 0 → stop < start → False | false |
HomotopyCategory.spectralObjectMappingCone._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C]
(D₁ D₂ : CategoryTheory.ComposableArrows (CochainComplex C ℤ) 2) (φ : D₁ ⟶ D₂),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.ComposableArrows.... | false |
MeasureTheory.VectorMeasure.instAddCommGroup._proof_3 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M] [IsTopologicalAddGroup M],
ContinuousConstSMul ℤ M | false |
AlgebraicGeometry.Scheme.GlueData.instPreservesColimitWalkingMultispanProdJMultispanDiagramForget | Mathlib.AlgebraicGeometry.Gluing | ∀ (D : AlgebraicGeometry.Scheme.GlueData),
CategoryTheory.Limits.PreservesColimit D.diagram.multispan AlgebraicGeometry.Scheme.forget | true |
Lean.MonadNameGenerator.setNGen | Init.Meta.Defs | {m : Type → Type} → [self : Lean.MonadNameGenerator m] → Lean.NameGenerator → m Unit | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.partialMatch_add_one_add_one_iff._proof_1_9 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : ByteArray} {s : ByteArray} {stackPos : ℕ} {needlePos : ℕ}, stackPos + 1 ≤ s.size → ¬stackPos < s.size → False | false |
Std.Sat.AIG.Entrypoint.ref | Std.Sat.AIG.Basic | {α : Type} → [inst : DecidableEq α] → [inst_1 : Hashable α] → (self : Std.Sat.AIG.Entrypoint α) → self.aig.Ref | true |
Aesop.PhaseSpec.ctorIdx | Aesop.Builder.Basic | Aesop.PhaseSpec → ℕ | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_27 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (i : ℕ), i + 1 ≤ f.clauses.size → i < f.clauses.size | false |
CategoryTheory.MonoidalCategory.DayConvolution.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convol... | false |
IsCoinitial | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → Prop | true |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mkNaturalityRightUnitor | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality m] →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr | true |
Lean.Lsp.DependencyBuildMode.recOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.DependencyBuildMode → Sort u} →
(t : Lean.Lsp.DependencyBuildMode) →
motive Lean.Lsp.DependencyBuildMode.always →
motive Lean.Lsp.DependencyBuildMode.once → motive Lean.Lsp.DependencyBuildMode.never → motive t | false |
_private.Mathlib.NumberTheory.LucasLehmer.0.Mathlib.Meta.Positivity.evalMersenne._sparseCasesOn_4 | Mathlib.NumberTheory.LucasLehmer | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{pα : Q(PartialOrder «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u} →
(t : Mathlib.Meta.Positivity.Strictness zα pα e) →
((pf : Q(0 < «$e»)) → motive (Mathlib.Meta.... | false |
TopCat.GlueData.MkCore.mk.sizeOf_spec | Mathlib.Topology.Gluing | ∀ {J : Type u} (U : J → TopCat) (V : (i : J) → J → TopologicalSpace.Opens ↑(U i))
(t :
(i j : J) →
(TopologicalSpace.Opens.toTopCat (U i)).obj (V i j) ⟶ (TopologicalSpace.Opens.toTopCat (U j)).obj (V j i))
(V_id : ∀ (i : J), V i i = ⊤) (t_id : ∀ (i : J), ⇑(CategoryTheory.ConcreteCategory.hom (t i i)) = id... | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.toPreOneHypercover_Y | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X) (x x_1 : data.I₀)
(j : data.I₁ x x_1), data.toPreOneHypercover.Y j = F.obj (data.Y j) | true |
GroupCone.mem_oneLE._simp_2 | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : CommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedMonoid H] {a : H},
(a ∈ GroupCone.oneLE H) = (1 ≤ a) | false |
PFun.restrict | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (f : α →. β) → {p : Set α} → p ⊆ f.Dom → α →. β | true |
symmDiff_eq_bot._simp_1 | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, (symmDiff a b = ⊥) = (a = b) | false |
Std.DTreeMap.Internal.Impl.balanceL.match_3.congr_eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTre... | true |
Std.Sat.AIG.ExtendTarget.w | Std.Sat.AIG.Basic | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {aig : Std.Sat.AIG α} → {newWidth : ℕ} → aig.ExtendTarget newWidth → ℕ | true |
Lean.Syntax.getOptional? | Init.Prelude | Lean.Syntax → Option Lean.Syntax | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_eq_get!_getKey?._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Array.find? | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Option α | true |
Nat.Partrec.below.casesOn | Mathlib.Computability.Partrec | ∀ {motive : (a : ℕ →. ℕ) → Nat.Partrec a → Prop}
{motive_1 : {a : ℕ →. ℕ} → (t : Nat.Partrec a) → Nat.Partrec.below t → Prop} {a : ℕ →. ℕ} {t : Nat.Partrec a}
(t_1 : Nat.Partrec.below t),
motive_1 Nat.Partrec.zero ⋯ →
motive_1 Nat.Partrec.succ ⋯ →
motive_1 Nat.Partrec.left ⋯ →
motive_1 Nat.Partr... | false |
Multiset.prod_min_le | Mathlib.Algebra.Order.BigOperators.Group.Multiset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : LinearOrder α] [IsOrderedMonoid α] {s : Multiset ι}
{f g : ι → α}, (Multiset.map (fun i => min (f i) (g i)) s).prod ≤ min (Multiset.map f s).prod (Multiset.map g s).prod | true |
spectrum_realPart' | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.RealImaginaryPart | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : Algebra ℂ A]
[inst_4 : StarModule ℂ A] [ContinuousFunctionalCalculus ℂ A IsStarNormal] (a : A),
autoParam (IsStarNormal a) spectrum_realPart'._auto_1 → spectrum ℝ ↑(realPart a) = Complex.re '' spectrum ℂ a | true |
NeZero | Init.Data.NeZero | {R : Type u_1} → [Zero R] → R → Prop | true |
Vector.snd_lt_add_of_mem_zipIdx | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {x : α × ℕ} {k : ℕ} {xs : Vector α n}, x ∈ xs.zipIdx k → x.2 < k + n | true |
ArchimedeanClass.exists_int_ge_of_mk_nonneg | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {x : R},
0 ≤ ArchimedeanClass.mk x → ∃ n, x ≤ ↑n | true |
CliffordAlgebra.EvenHom.mk | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] →
(bilin : M →ₗ[R] M →ₗ[R] A) →
... | true |
Std.DTreeMap.Internal.Cell.get?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.OrientedOrd α] [inst_2 : Std.LawfulEqOrd α] {k : α}
(c : Std.DTreeMap.Internal.Cell α β (compare k)),
c.get? =
match h : c.inner with
| none => none
| some p => some (cast ⋯ p.snd) | true |
DFinsupp.instCanonicallyOrderedAddOfAddLeftMono | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} (α : ι → Type u_2) [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)] [∀ (i : ι), OrderedSub (α i)]
[∀ (i : ι), AddLeftMono (α i)], CanonicallyOrderedAdd (Π₀ (i : ι), α i) | true |
ClosureOperator.noConfusion | Mathlib.Order.Closure | {P : Sort u} →
{α : Type u_1} →
{inst : Preorder α} →
{t : ClosureOperator α} →
{α' : Type u_1} →
{inst' : Preorder α'} →
{t' : ClosureOperator α'} → α = α' → inst ≍ inst' → t ≍ t' → ClosureOperator.noConfusionType P t t' | false |
_private.Init.Data.List.Find.0.List.lt_findIdx_iff._proof_1_3 | Init.Data.List.Find | ∀ {α : Type u_1} (xs : List α) (p : α → Bool),
∀ i < List.findIdx p xs, List.findIdx p xs ≤ xs.length → ¬i < xs.length → False | false |
Lean.Lsp.InlayHintParams | Lean.Data.Lsp.LanguageFeatures | Type | true |
DifferentiableOn.sum | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{ι : Type u_4} {u : Finset ι} {A : ι → E → F},
(∀ i ∈ u, DifferentiableOn 𝕜 (A i) s) → Differenti... | true |
MeasurableEquiv.piCongrLeft.eq_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {δ : Type u_4} {δ' : Type u_5} (π : δ' → Type u_6) [inst : (x : δ') → MeasurableSpace (π x)] (f : δ ≃ δ'),
MeasurableEquiv.piCongrLeft π f = { toEquiv := Equiv.piCongrLeft π f, measurable_toFun := ⋯, measurable_invFun := ⋯ } | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabUnsafe._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
PartOrdEmb.of.injEq | Mathlib.Order.Category.PartOrdEmb | ∀ (carrier : Type u_1) [str : PartialOrder carrier] (carrier_1 : Type u_1) (str_1 : PartialOrder carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) | true |
Batteries.CodeAction.instInhabitedTacticCodeActionEntry.default | Batteries.CodeAction.Attr | Batteries.CodeAction.TacticCodeActionEntry | true |
neZero_iff | Init.Data.NeZero | ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n ↔ n ≠ 0 | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Basic.0.CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_inv_app_eq._simp_1_2 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
CategoryTheory.ObjectProperty.coproductFromFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.CostructuredArrow P.ι X → C | true |
StieltjesFunction.mk.inj | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} {inst : LinearOrder R} {inst_1 : TopologicalSpace R} {toFun : R → ℝ} {mono' : Monotone toFun}
{right_continuous' : ∀ (x : R), ContinuousWithinAt toFun (Set.Ici x) x} {toFun_1 : R → ℝ} {mono'_1 : Monotone toFun_1}
{right_continuous'_1 : ∀ (x : R), ContinuousWithinAt toFun_1 (Set.Ici x) x},
{ toFun... | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._simp_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} {a b : Additive α}, (a = b) = (Additive.toMul a = Additive.toMul b) | false |
LightProfinite.instEpiAppOppositeNatπAsLimitCone | Mathlib.Topology.Category.LightProfinite.Extend | ∀ (S : LightProfinite) (i : ℕᵒᵖ), CategoryTheory.Epi (S.asLimitCone.π.app i) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.