name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Elab.Inductive.0.Lean.Elab.Command.inductiveSyntaxToView.match_9 | Lean.Elab.Inductive | (motive : Lean.Syntax × Option Lean.Syntax → Sort u_1) →
(x : Lean.Syntax × Option Lean.Syntax) →
((binders : Lean.Syntax) → (type? : Option Lean.Syntax) → motive (binders, type?)) → motive x | false |
Nat.monotone_primeCounting | Mathlib.NumberTheory.PrimeCounting | Monotone Nat.primeCounting | true |
HasFPowerSeriesOnBall.pi | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_9} [inst_3 : Fintype ι] {e : E} {Fm : ι → Type u_10}
[inst_4 : (i : ι) → NormedAddCommGroup (Fm i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (Fm i)] {f : (i : ι) → E → Fm i}
{r : ... | true |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.smul.eq_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {S : Type u_3} [inst_1 : SMulZeroClass S k] (x : S) (b : G →₀ k),
SkewMonoidAlgebra.smul✝ x { toFinsupp := b } = { toFinsupp := x • b } | true |
alexDiscEquivPreord._proof_5 | Mathlib.Topology.Order.Category.AlexDisc | ∀ (X : AlexDisc),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord).map
((CategoryTheory.NatIso.ofComponents
(fun X => AlexDisc.Iso.mk (id (homeoWithUpperSetTopologyorderIso ↑X.toTopCat)))
@alexDiscEquivPreord._proof_3).hom.ap... | false |
Aesop.EqualUpToIdsM.State.mk.inj | Aesop.Util.EqualUpToIds | ∀ {equalMVarIds : Std.HashMap Lean.MVarId Lean.MVarId} {equalLMVarIds : Std.HashMap Lean.LMVarId Lean.LMVarId}
{leftUnassignedMVarValues rightUnassignedMVarValues : Std.HashMap Lean.MVarId Lean.Expr}
{equalMVarIds_1 : Std.HashMap Lean.MVarId Lean.MVarId} {equalLMVarIds_1 : Std.HashMap Lean.LMVarId Lean.LMVarId}
{... | true |
MeasureTheory.weightedSMul_union | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (s t : Set α),
MeasurableSet s →
MeasurableSet t →
μ s ≠ ⊤ →
μ t ≠ ⊤ →
Disjoint s t →
MeasureTheory.weightedSMul μ (s ∪ t) = MeasureT... | true |
_private.Mathlib.RingTheory.Multiplicity.0.FiniteMultiplicity.or_of_add._simp_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Add α] [inst_1 : Semigroup α] [LeftDistribClass α] {a b c : α},
a ∣ b → a ∣ c → (a ∣ b + c) = True | false |
_private.Mathlib.Order.SuccPred.Basic.0.Order.Ico_pred_right_eq_insert._simp_1_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b | false |
Lean.Elab.Command.Structure.StructParentInfo.mk._flat_ctor | Lean.Elab.Structure | Lean.Syntax → Bool → Lean.Expr → Lean.Name → Lean.Name → Lean.Name → Bool → Lean.Elab.Command.Structure.StructParentInfo | false |
AddSubgroup.rightCosetEquivAddSubgroup._proof_5 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (g : α) (x : ↑(AddOpposite.op g +ᵥ ↑s)),
∃ a ∈ ↑s, AddOpposite.op g +ᵥ a = ↑⟨↑x + -g, ⋯⟩ + g | false |
IsAlgebraic.inv_iff | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} [inst : CommRing R] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R K] {x : K},
IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x | true |
Ordnode.instInsert | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → Insert α (Ordnode α) | true |
Lean.Meta.Grind.TopSort.State.mk.inj | Lean.Meta.Tactic.Grind.EqResolution | ∀ {tempMark permMark : Std.HashSet Lean.Expr} {result : Array Lean.Expr} {tempMark_1 permMark_1 : Std.HashSet Lean.Expr}
{result_1 : Array Lean.Expr},
{ tempMark := tempMark, permMark := permMark, result := result } =
{ tempMark := tempMark_1, permMark := permMark_1, result := result_1 } →
tempMark = temp... | true |
List.Sublist.reverse | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.reverse.Sublist l₂.reverse | true |
SeparationQuotient.inseparableSetoid_eq_top_iff | Mathlib.Topology.Inseparable | ∀ {α : Type u_4} [inst : TopologicalSpace α], inseparableSetoid α = ⊤ ↔ IndiscreteTopology α | true |
MeasureTheory.MemLp.comp_fst | Mathlib.MeasureTheory.Function.LpSeminorm.Prod | ∀ {α : Type u_1} {β : Type u_2} {ε : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] {μ : MeasureTheory.Measure α} {p : ENNReal} {f : α → ε},
MeasureTheory.MemLp f p μ →
∀ (ν : MeasureTheory.Measure β) [MeasureTheory.IsFiniteMeasure ν], Measur... | true |
Orientation.definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.Orientation.2114562672._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] (o : Orientation ℝ E (Fin 0)),
o = positiveOrientation ∨ o = -positiveOrientation | false |
List.scanr_ne_nil | Init.Data.List.Scan.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {b : β} {l : List α} {f : α → β → β}, List.scanr f b l ≠ [] | true |
_private.Mathlib.Data.Set.Card.0.Set.three_lt_ncard._simp_1_1 | Mathlib.Data.Set.Card | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | false |
Mathlib.Tactic.Widget.StringDiagram.Node.id.inj | Mathlib.Tactic.Widget.StringDiagram | ∀ {a a_1 : Mathlib.Tactic.Widget.StringDiagram.IdNode},
Mathlib.Tactic.Widget.StringDiagram.Node.id a = Mathlib.Tactic.Widget.StringDiagram.Node.id a_1 → a = a_1 | true |
extDerivWithin_constOfIsEmpty | Mathlib.Analysis.Calculus.DifferentialForm.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {x : E} (f : E → F),
UniqueDiffWithinAt 𝕜 s x →
extDerivWithin (fun x => ContinuousAlternatingM... | true |
_private.Init.Data.String.Lemmas.Pattern.Memcmp.0.String.Slice.Pattern.Internal.memcmpStr_eq_true_iff._proof_1_18 | Init.Data.String.Lemmas.Pattern.Memcmp | ∀ {lhs rhs : String} {lstart rstart : String.Pos.Raw} {len : String.Pos.Raw} (p : String.Pos.Raw),
p.byteIdx < len.byteIdx → ¬0 < len.byteIdx - p.byteIdx → False | false |
CategoryTheory.Functor.IsLocallyDirected.recOn | Mathlib.CategoryTheory.LocallyDirected | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{F : CategoryTheory.Functor J (Type u_2)} →
{motive : F.IsLocallyDirected → Sort u} →
(t : F.IsLocallyDirected) →
((cond :
∀ {i j k : J} (fi : i ⟶ k) (fj : j ⟶ k) (xi : F.obj i) (xj : F.obj j),
... | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Bounds.0.norm_iteratedFDerivWithin_comp_le._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Int8.toInt_div | Init.Data.SInt.Lemmas | ∀ (a b : Int8), (a / b).toInt = (a.toInt.tdiv b.toInt).bmod (2 ^ 8) | true |
ContinuousMultilinearMap.compAlongComposition._proof_3 | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_4} {E : Type u_1} {F : Type u_3} {G : Type u_2} [inst : CommRing 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : AddCommGroup F] [inst_3 : AddCommGroup G] [inst_4 : Module 𝕜 E] [inst_5 : Module 𝕜 F] [inst_6 : Module 𝕜 G]
[inst_7 : TopologicalSpace E] [inst_8 : TopologicalSpace F] [inst_9 : TopologicalSpac... | false |
Polynomial.nthRootsFinset_def | Mathlib.Algebra.Polynomial.Roots | ∀ (n : ℕ) {R : Type u_1} (a : R) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DecidableEq R],
Polynomial.nthRootsFinset n a = (Polynomial.nthRoots n a).toFinset | true |
DirectSum.id._proof_1 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι],
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) 0) = 0 | false |
_private.Init.Data.Vector.Erase.0.Vector.eraseIdx_append._proof_3 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n + m → ¬k < n → ¬k - n < m → False | false |
Primrec.list_cons | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ List.cons | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFnM.go._unary._proof_2 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} (i : ℕ) (acc : Array α), acc.size = i → ∀ (__do_lift : α), (acc.push __do_lift).size = i + 1 | false |
AlgebraicGeometry.instIsStableUnderCompositionSchemeLocallyOfFiniteType | Mathlib.AlgebraicGeometry.Morphisms.FiniteType | CategoryTheory.MorphismProperty.IsStableUnderComposition @AlgebraicGeometry.LocallyOfFiniteType | true |
Pregroupoid.mk._flat_ctor | Mathlib.Geometry.Manifold.StructureGroupoid | {H : Type u_2} →
[inst : TopologicalSpace H] →
(property : (H → H) → Set H → Prop) →
(∀ {f g : H → H} {u v : Set H},
property f u → property g v → IsOpen u → IsOpen v → IsOpen (u ∩ f ⁻¹' v) → property (g ∘ f) (u ∩ f ⁻¹' v)) →
property id Set.univ →
(∀ {f : H → H} {u : Set H}, IsO... | false |
Array.eraseIdxIfInBounds | Init.Data.Array.Basic | {α : Type u} → Array α → ℕ → Array α | true |
ArithmeticFunction.instModule._proof_5 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid S] [inst_2 : Module R S] (x : R)
(f g : ArithmeticFunction S), x • (f + g) = x • f + x • g | false |
Set.compl_Ioc | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (Set.Ioc a b)ᶜ = Set.Iic a ∪ Set.Ioi b | true |
Finsupp.instNonUnitalNonAssocRing._proof_6 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalNonAssocRing β] (g₁ g₂ : α →₀ β), ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂ | false |
Std.ExtTreeSet.toArray | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → Array α | true |
Mathlib.Tactic.Order.AtomicFact.lt | Mathlib.Tactic.Order.CollectFacts | ℕ → ℕ → Lean.Expr → Mathlib.Tactic.Order.AtomicFact | true |
CategoryTheory.Limits.Cotrident.ext._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {s t : CategoryTheory.Limits.Cotrident f} (i : s.pt ≅ t.pt)
(w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cotrident.... | false |
Array.forIn'_yield_eq_foldlM | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β γ : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array α}
(f : (a : α) → a ∈ xs → β → m γ) (g : (a : α) → a ∈ xs → β → γ → β) (init : β),
(forIn' xs init fun a m_1 b => (fun c => ForInStep.yield (g a m_1 b c)) <$> f a m_1 b) =
Array.foldlM
(fun b x =>
... | true |
Std.Sat.AIG.CacheHit.casesOn | Std.Sat.AIG.Basic | {α : Type} →
{decls : Array (Std.Sat.AIG.Decl α)} →
{decl : Std.Sat.AIG.Decl α} →
{motive : Std.Sat.AIG.CacheHit decls decl → Sort u} →
(t : Std.Sat.AIG.CacheHit decls decl) →
((idx : ℕ) →
(hbound : idx < decls.size) →
(hvalid : decls[idx] = decl) → motive { i... | false |
Std.Tactic.BVDecide.LRAT.Internal.Clause.eval | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : Type u_1} → {β : Type u_2} → [Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → (α → Bool) → β → Bool | true |
Std.Time.TimeZone | Std.Time.Zoned.TimeZone | Type | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (a b toIntThm : Lean.Expr) (lhs rhs : Int.Linear.Expr) (a_1 b_1 toIntThm_1 : Lean.Expr)
(lhs_1 rhs_1 : Int.Linear.Expr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a b toIntThm lhs rhs =
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a_1 b_1 toIntThm_1 lhs_1 rhs_1) =
(a = a_1 ∧ b = ... | true |
Prime.nat_prime | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Prime p → Nat.Prime p | true |
Bundle.Pretrivialization.continuousOn_continuousLinearMapCoordChange | Mathlib.Topology.VectorBundle.Hom | ∀ {𝕜₁ : Type u_1} [inst : NontriviallyNormedField 𝕜₁] {𝕜₂ : Type u_2} [inst_1 : NontriviallyNormedField 𝕜₂]
{σ : 𝕜₁ →+* 𝕜₂} {B : Type u_3} {F₁ : Type u_4} [inst_2 : NormedAddCommGroup F₁] [inst_3 : NormedSpace 𝕜₁ F₁]
{E₁ : B → Type u_5} [inst_4 : (x : B) → AddCommGroup (E₁ x)] [inst_5 : (x : B) → Module 𝕜₁ ... | true |
Batteries.RBNode.Path.Balanced.brecOn | Batteries.Data.RBMap.Alter | ∀ {c₀ : Batteries.RBColor} {n₀ : ℕ} {α : Type u_1}
{motive :
(a : Batteries.RBNode.Path α) →
(a_1 : Batteries.RBColor) → (a_2 : ℕ) → Batteries.RBNode.Path.Balanced c₀ n₀ a a_1 a_2 → Prop}
{a : Batteries.RBNode.Path α} {a_1 : Batteries.RBColor} {a_2 : ℕ}
(t : Batteries.RBNode.Path.Balanced c₀ n₀ a a_1 a_... | true |
CategoryTheory.Limits.BinaryBicone.ofColimitCocone._proof_8 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsColimit t),
CategoryTheory.CategoryStruct.comp (t.ι.app { as := CategoryTheory.Limits.WalkingPair.right }... | false |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.exists_lt_omega0_opow' | Mathlib.SetTheory.Ordinal.Notation | ∀ {α : Sort u_1} {o b : Ordinal.{u_2}},
1 < b →
Order.IsSuccLimit o →
∀ {f : α → Ordinal.{u_2}},
(∀ ⦃a : Ordinal.{u_2}⦄, a < o → ∃ i, a < f i) → ∀ ⦃a : Ordinal.{u_2}⦄, a < b ^ o → ∃ i, a < b ^ f i | true |
StarRingEquivClass.toStarRingEquiv.congr_simp | Mathlib.Algebra.Star.StarAlgHom | ∀ {F : Type u_1} {A : Type u_2} {B : Type u_3} [inst : Add A] [inst_1 : Mul A] [inst_2 : Star A] [inst_3 : Add B]
[inst_4 : Mul B] [inst_5 : Star B] [inst_6 : EquivLike F A B] [inst_7 : RingEquivClass F A B]
[inst_8 : StarRingEquivClass F A B] (f f_1 : F), f = f_1 → ↑f = ↑f_1 | true |
CategoryTheory.MonoidalCategory.whiskerLeft_inv_hom' | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C) {Y Z : C}
(f : Y ⟶ Z) [inst_2 : CategoryTheory.IsIso f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.inv f))
(CategoryTheory.MonoidalCategor... | true |
Option.forIn_yield_eq_elim | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β γ : Type u_1} [inst : Monad m] [LawfulMonad m] (o : Option α)
(f : α → β → m γ) (g : α → β → γ → β) (b : β),
(forIn o b fun a b => (fun c => ForInStep.yield (g a b c)) <$> f a b) = o.elim (pure b) fun a => g a b <$> f a b | true |
Real.tan_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ (x : ℝ), Real.tan (Real.arccos x) = √(1 - x ^ 2) / x | true |
_private.Init.Data.Option.Lemmas.0.Option.not_rel_none_some.match_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {a : β} {r : α → β → Prop} (motive : Option.Rel r none (some a) → Prop)
(a : Option.Rel r none (some a)), motive a | false |
Algebra.TensorProduct.mul | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalNonAssocSemiring B] →
[i... | true |
CategoryTheory.ExponentiableMorphism.unit_pushforwardComp_hom_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I J K : C} (f : I ⟶ J) (g : J ⟶ K)
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] [inst_2 : CategoryTheory.ChosenPullbacksAlong g]
[inst_3 : CategoryTheory.ChosenPullbacksAlong (CategoryTheory.CategoryStruct.comp f g)]
[inst_4 : CategoryTheory.Exponentia... | true |
ContinuousMultilinearMap.alternatization._proof_3 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_4} {M : Type u_1} {N : Type u_2} {ι : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : IsTopologicalAddGroup N] [inst_8 : Fintype ι] [inst_9 : DecidableEq... | false |
CategoryTheory.BiconeHom.decidableEq._proof_11 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} J]
(g : CategoryTheory.BiconeHom J CategoryTheory.Bicone.right CategoryTheory.Bicone.right), g ≍ g | false |
BitVec.ofNat_toNat | Init.Data.BitVec.Bootstrap | ∀ {n : ℕ} (m : ℕ) (x : BitVec n), BitVec.ofNat m x.toNat = BitVec.setWidth m x | true |
_private.Init.Data.List.Perm.0.List.perm_middle.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (b : α) (tail x : List α), motive (b :: tail) x) → motive x x_1 | false |
Lean.Elab.Term.Do.ToTerm.Kind._sizeOf_1 | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind → ℕ | false |
Filter.HasBasis.lift | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {γ : Type u_3} {ι : Type u_6} {p : ι → Prop} {s : ι → Set α} {f : Filter α},
f.HasBasis p s →
∀ {β : ι → Type u_5} {pg : (i : ι) → β i → Prop} {sg : (i : ι) → β i → Set γ} {g : Set α → Filter γ},
(∀ (i : ι), (g (s i)).HasBasis (pg i) (sg i)) →
Monotone g → (f.lift g).HasBasis (fun i... | true |
CoalgebraStruct.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] → (A →ₗ[R] TensorProduct R A A) → (A →ₗ[R] R) → CoalgebraStruct R A | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.filterMap._proof_9 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(St... | false |
CategoryTheory.ShortComplex.Homotopy.symm_h₀ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
h.symm.h₀ = -h.h₀ | true |
QuadraticModuleCat.ofIso._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} [inst_1 : AddCommGroup X] [inst_2 : Module R X]
[inst_3 : AddCommGroup Y] [inst_4 : Module R Y] {Q₁ : QuadraticForm R X} {Q₂ : QuadraticForm R Y}
(e : QuadraticMap.IsometryEquiv Q₁ Q₂),
CategoryTheory.CategoryStruct.comp (QuadraticModuleCat.ofHom e.symm.toIsom... | false |
Batteries.CodeAction.startTacticStub | Batteries.CodeAction.Misc | Lean.CodeAction.HoleCodeAction | true |
PrimeMultiset.prod_dvd_prod | Mathlib.Data.PNat.Factors | ∀ {u v : PrimeMultiset}, u ≤ v → u.prod ∣ v.prod | true |
AlgebraicGeometry.ExistsHomHomCompEqCompAux._sizeOf_inst | Mathlib.AlgebraicGeometry.AffineTransitionLimit | {I : Type u} →
{inst : CategoryTheory.Category.{u, u} I} →
{S X : AlgebraicGeometry.Scheme} →
(D : CategoryTheory.Functor I AlgebraicGeometry.Scheme) →
(t : D ⟶ (CategoryTheory.Functor.const I).obj S) →
(f : X ⟶ S) → [SizeOf I] → SizeOf (AlgebraicGeometry.ExistsHomHomCompEqCompAux D t f) | false |
Lean.Lsp.DocumentColorParams.workDoneToken?._inherited_default | Lean.Data.Lsp.LanguageFeatures | Option Lean.Lsp.ProgressToken | false |
_private.Std.Data.DHashMap.Internal.HashesTo.0.Std.DHashMap.Internal.List.HashesTo.containsKey_eq_false._simp_1_1 | Std.Data.DHashMap.Internal.HashesTo | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α},
(Std.Internal.List.containsKey a l = true) = ∃ p ∈ l, (p.fst == a) = true | false |
Additive.subtractionMonoid._proof_1 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (x : Additive α), - -x = x | false |
MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_sum_measure | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {s : Finset ι} {t : ι → Set α},
(∀ i ∈ s, MeasureTheory.NullMeasurableSet (t i) μ) →
μ Set.univ < ∑ i ∈ s, μ (t i) → ∃ i ∈ s, ∃ j ∈ s, ∃ (_ : i ≠ j), (t i ∩ t j).Nonempty | true |
Lean.Doc.MarkdownM.Context.inLink._default | Lean.DocString.Markdown | Bool | false |
CategoryTheory.Limits.botSquareIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{Y₃ Y₂ Y₁ X₃ : C} →
{g₂ : Y₃ ⟶ Y₂} →
{g₁ : Y₂ ⟶ Y₁} →
{i₃ : Y₃ ⟶ X₃} →
{t₁ : CategoryTheory.Limits.PushoutCocone g₂ i₃} →
{i₂ : Y₂ ⟶ t₁.pt} →
(t₂ : CategoryTheory.Limits.PushoutCocone g₁ i₂... | true |
Std.TreeSet.Raw.insert | Std.Data.TreeSet.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet.Raw α cmp → α → Std.TreeSet.Raw α cmp | true |
List.min?_eq_some_iff_subtype | Init.Data.List.MinMax | ∀ {α : Type u_1} {a : α} [inst : Min α] [inst_1 : LE α] {xs : List α} [inst_2 : Std.MinEqOr α]
[Std.IsLinearOrder { x // x ∈ xs }] [Std.LawfulOrderMin { x // x ∈ xs }], xs.min? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, a ≤ b | true |
Finset.disjSups_empty_left | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] [inst_2 : OrderBot α]
[inst_3 : DecidableRel Disjoint] {t : Finset α}, ∅.disjSups t = ∅ | true |
CategoryTheory.Functor.instLaxMonoidalMonMapAddMon._proof_6 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.BraidedCategory C]
[inst_5 : CategoryThe... | false |
_private.Mathlib.Order.Filter.AtTopBot.ModEq.0.Nat.frequently_even._simp_1_1 | Mathlib.Order.Filter.AtTopBot.ModEq | ∀ {n : ℕ}, Even n = (n % 2 = 0) | false |
EMetric.hausdorffEdist_union_le | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s₁ s₂ t₁ t₂ : Set α},
Metric.hausdorffEDist (s₁ ∪ s₂) (t₁ ∪ t₂) ≤ max (Metric.hausdorffEDist s₁ t₁) (Metric.hausdorffEDist s₂ t₂) | true |
Decidable.rec | Init.Prelude | {p : Prop} →
{motive : Decidable p → Sort u} →
((h : ¬p) → motive (isFalse h)) → ((h : p) → motive (isTrue h)) → (t : Decidable p) → motive t | false |
NNReal.coe_multiset_prod | Mathlib.Data.NNReal.Basic | ∀ (s : Multiset NNReal), ↑s.prod = (Multiset.map NNReal.toReal s).prod | true |
SModEq.bot | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
x ≡ y [SMOD ⊥] ↔ x = y | true |
imp_congr_left | Init.Core | ∀ {a b c : Prop}, (a ↔ b) → (a → c ↔ b → c) | true |
ContinuousOn.div₀ | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀] [ContinuousInv₀ G₀]
[ContinuousMul G₀] {f g : α → G₀} [inst_4 : TopologicalSpace α] {s : Set α},
ContinuousOn f s → ContinuousOn g s → (∀ x ∈ s, g x ≠ 0) → ContinuousOn (fun x => f x / g x) s | true |
CategoryTheory.Presieve.bind | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(S : CategoryTheory.Presieve X) →
(⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y) → CategoryTheory.Presieve X | true |
HasSum.tsum_fiberwise | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [IsUniformAddGroup α]
[CompleteSpace α] [T2Space α] {f : β → α} {a : α},
HasSum f a → ∀ (g : β → γ), HasSum (fun c => ∑' (b : ↑(g ⁻¹' {c})), f ↑b) a | true |
_private.Mathlib.Algebra.Star.LinearMap.0.LinearMap.IntrinsicStar.isSelfAdjoint_iff_map_star._simp_1_3 | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u} [inst : InvolutiveStar R] {r s : R}, (star r = s) = (star s = r) | false |
FourierInvModule.toFourierTransformInv | Mathlib.Analysis.Fourier.Notation | {R : Type u_5} →
{E : Type u_6} →
{F : outParam (Type u_7)} →
[inst : Add E] →
[inst_1 : Add F] → [inst_2 : SMul R E] → [inst_3 : SMul R F] → FourierInvModule R E F → FourierTransformInv E F | true |
_private.Lean.Compiler.ExternAttr.0.Lean.parseOptNum._sunfold | Lean.Compiler.ExternAttr | ℕ → (pattern : String) → pattern.Pos → ℕ → pattern.Pos × ℕ | false |
StandardSubspace.mulI._proof_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] (S : StandardSubspace H),
S.toClosedSubmodule.mulI ⊓ S.toClosedSubmodule.mulI.mulI = ⊥ | false |
differentiableAt_comp_const_sub | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {a b : 𝕜},
DifferentiableAt 𝕜 (fun x => f (b - x)) a ↔ DifferentiableAt 𝕜 f (b - a) | true |
MeasureTheory.Measure.IsNegInvariant.recOn | Mathlib.MeasureTheory.Group.Measure | {G : Type u_1} →
[inst : MeasurableSpace G] →
[inst_1 : Neg G] →
{μ : MeasureTheory.Measure G} →
{motive : μ.IsNegInvariant → Sort u} →
(t : μ.IsNegInvariant) → ((neg_eq_self : μ.neg = μ) → motive ⋯) → motive t | false |
ContinuousMap.Homotopy.comp._proof_2 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_3} {Y : Type u_2} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Y, Z)} (G : g₀.Homotopy g₁) (F : f₀.Homotopy f₁) (x : X),
G ((0, x).1, F (0, x)) = (g₀.comp f₀) x | false |
_private.Mathlib.Tactic.ITauto.0.Mathlib.Tactic.ITauto.search._sparseCasesOn_16 | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.IProp → Sort u} →
(t : Mathlib.Tactic.ITauto.IProp) →
((a a_1 : Mathlib.Tactic.ITauto.IProp) → motive (a.or a_1)) → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Hyperreal.isSt_refl_real | Mathlib.Analysis.Real.Hyperreal | ∀ (r : ℝ), (↑r).IsSt r | true |
Nat.bodd_one | Mathlib.Data.Nat.Bits | Nat.bodd 1 = true | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.