name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
map_rat_smul | Mathlib.Algebra.Module.Rat | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] [_instM : Module ℚ M]
[_instM₂ : Module ℚ M₂] {F : Type u_3} [inst_2 : FunLike F M M₂] [AddMonoidHomClass F M M₂] (f : F) (c : ℚ) (x : M),
f (c • x) = c • f x |
_private.Mathlib.Topology.Order.MonotoneConvergence.0.Pi.supConvergenceClass._simp_2 | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range (s.restrict f) |
«_aux_Mathlib_Tactic_TypeStar___elabRules_termSort*_1» | Mathlib.Tactic.TypeStar | Lean.Elab.Term.TermElab |
NormedRing.induced._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_2} (R : Type u_1) (S : Type u_3) [inst : FunLike F R S] [inst_1 : Ring R] [inst_2 : NormedRing S]
[inst_3 : NonUnitalRingHomClass F R S] (f : F) (hf : Function.Injective ⇑f) {x y : R}, dist x y = 0 → x = y |
CategoryTheory.Limits.coconeOfCoconeUncurryIsColimit._proof_3 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_4} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → CategoryTheory.Limits.IsColimit (D.obj j))
{c : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.uncurry.obj F)} (P : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.Cocone D.coconePoints) (m : (CategoryTheory.Limits.coconeOfCoconeUncurry Q c).pt ⟶ s.pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.coconeOfCoconeUncurry Q c).ι.app j) m = s.ι.app j) →
m =
P.desc
{ pt := s.pt,
ι :=
{ app := fun p => CategoryTheory.CategoryStruct.comp ((D.obj p.1).ι.app p.2) (s.ι.app p.1),
naturality := ⋯ } } |
Polynomial.natTrailingDegree_mul' | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
p.trailingCoeff * q.trailingCoeff ≠ 0 → (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree |
Finpartition.combine._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {ι : Type u_2} {I : Finset ι}
{a : ι → α} (P : (i : ι) → Finpartition (a i)), (I.biUnion fun i => (P i).parts).sup id = I.sup a |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_umod._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ}, ¬i < w → ¬w ≤ i → False |
Commute.intCast_right | Mathlib.Data.Int.Cast.Lemmas | ∀ {α : Type u_3} [inst : NonAssocRing α] {a : α} {n : ℤ}, Commute a ↑n |
_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 |
Nat.monotone_primeCounting | Mathlib.NumberTheory.PrimeCounting | Monotone Nat.primeCounting |
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 : ENNReal} {p : (i : ι) → FormalMultilinearSeries 𝕜 E (Fm i)},
(∀ (i : ι), HasFPowerSeriesOnBall (f i) (p i) e r) →
0 < r → HasFPowerSeriesOnBall (fun x x_1 => f x_1 x) (FormalMultilinearSeries.pi p) e r |
_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 } |
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.app
X))
((CategoryTheory.NatIso.ofComponents
(fun X => Preord.Iso.mk (id (orderIsoSpecializationWithUpperSetTopology ↑X).symm))
@alexDiscEquivPreord._proof_4).hom.app
(((CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord).obj X)) =
CategoryTheory.CategoryStruct.id (((CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord).obj X) |
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}
{leftUnassignedMVarValues_1 rightUnassignedMVarValues_1 : Std.HashMap Lean.MVarId Lean.Expr},
{ equalMVarIds := equalMVarIds, equalLMVarIds := equalLMVarIds, leftUnassignedMVarValues := leftUnassignedMVarValues,
rightUnassignedMVarValues := rightUnassignedMVarValues } =
{ equalMVarIds := equalMVarIds_1, equalLMVarIds := equalLMVarIds_1,
leftUnassignedMVarValues := leftUnassignedMVarValues_1,
rightUnassignedMVarValues := rightUnassignedMVarValues_1 } →
equalMVarIds = equalMVarIds_1 ∧
equalLMVarIds = equalLMVarIds_1 ∧
leftUnassignedMVarValues = leftUnassignedMVarValues_1 ∧ rightUnassignedMVarValues = rightUnassignedMVarValues_1 |
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) = MeasureTheory.weightedSMul μ s + MeasureTheory.weightedSMul μ t |
_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 |
_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 |
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 |
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 |
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 |
Ordnode.instInsert | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → Insert α (Ordnode α) |
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 = tempMark_1 ∧ permMark = permMark_1 ∧ result = result_1 |
List.Sublist.reverse | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.reverse.Sublist l₂.reverse |
SeparationQuotient.inseparableSetoid_eq_top_iff | Mathlib.Topology.Inseparable | ∀ {α : Type u_4} [inst : TopologicalSpace α], inseparableSetoid α = ⊤ ↔ IndiscreteTopology α |
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 ν], MeasureTheory.MemLp (fun x => f x.1) p (μ.prod ν) |
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 |
List.scanr_ne_nil | Init.Data.List.Scan.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {b : β} {l : List α} {f : α → β → β}, List.scanr f b l ≠ [] |
_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) |
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 |
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 => ContinuousAlternatingMap.constOfIsEmpty 𝕜 E (Fin 0) (f x)) s x =
(ContinuousAlternatingMap.ofSubsingleton 𝕜 E F 0) (fderivWithin 𝕜 f s x) |
_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 |
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),
F.map fi xi = F.map fj xj → ∃ l fli flj x, F.map fli x = xi ∧ F.map flj x = xj) →
motive ⋯) →
motive t |
_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) |
Int8.toInt_div | Init.Data.SInt.Lemmas | ∀ (a b : Int8), (a / b).toInt = (a.toInt.tdiv b.toInt).bmod (2 ^ 8) |
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 : TopologicalSpace G]
[inst_10 : IsTopologicalAddGroup E] [inst_11 : ContinuousConstSMul 𝕜 E] [inst_12 : IsTopologicalAddGroup F]
[inst_13 : ContinuousConstSMul 𝕜 F] {n : ℕ} (p : FormalMultilinearSeries 𝕜 E F) (c : Composition n)
(f : ContinuousMultilinearMap 𝕜 (fun i => F) G), Continuous (f.toFun ∘ p.applyComposition c) |
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 |
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 |
_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 |
Primrec.list_cons | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ List.cons |
_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 |
AlgebraicGeometry.instIsStableUnderCompositionSchemeLocallyOfFiniteType | Mathlib.AlgebraicGeometry.Morphisms.FiniteType | CategoryTheory.MorphismProperty.IsStableUnderComposition @AlgebraicGeometry.LocallyOfFiniteType |
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}, IsOpen u → (∀ x ∈ u, ∃ v, IsOpen v ∧ x ∈ v ∧ property f (u ∩ v)) → property f u) →
(∀ {f g : H → H} {u : Set H}, IsOpen u → (∀ x ∈ u, g x = f x) → property f u → property g u) → Pregroupoid H |
Array.eraseIdxIfInBounds | Init.Data.Array.Basic | {α : Type u} → Array α → ℕ → Array α |
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 |
Finsupp.instNonUnitalNonAssocRing._proof_6 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalNonAssocRing β] (g₁ g₂ : α →₀ β), ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂ |
Std.ExtTreeSet.toArray | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → Array α |
Mathlib.Tactic.Order.AtomicFact.lt | Mathlib.Tactic.Order.CollectFacts | ℕ → ℕ → Lean.Expr → Mathlib.Tactic.Order.AtomicFact |
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.mkHom i.inv ⋯)
(CategoryTheory.Limits.Cotrident.mkHom i.hom w) =
CategoryTheory.CategoryStruct.id t |
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 =>
match x with
| ⟨a, m_1⟩ => g a m_1 b <$> f a m_1 b)
init xs.attach |
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 { idx := idx, hbound := hbound, hvalid := hvalid }) →
motive t |
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 |
Std.Time.TimeZone | Std.Time.Zoned.TimeZone | Type |
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 = b_1 ∧ toIntThm = toIntThm_1 ∧ lhs = lhs_1 ∧ rhs = rhs_1) |
Prime.nat_prime | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Prime p → Nat.Prime p |
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 𝕜₁ (E₁ x)]
[inst_6 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_6} [inst_7 : NormedAddCommGroup F₂]
[inst_8 : NormedSpace 𝕜₂ F₂] {E₂ : B → Type u_7} [inst_9 : (x : B) → AddCommGroup (E₂ x)]
[inst_10 : (x : B) → Module 𝕜₂ (E₂ x)] [inst_11 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
[inst_12 : TopologicalSpace B] {e₁ e₁' : Bundle.Trivialization F₁ Bundle.TotalSpace.proj}
{e₂ e₂' : Bundle.Trivialization F₂ Bundle.TotalSpace.proj} [inst_13 : (x : B) → TopologicalSpace (E₁ x)]
[inst_14 : FiberBundle F₁ E₁] [inst_15 : (x : B) → TopologicalSpace (E₂ x)] [inst_16 : FiberBundle F₂ E₂]
[RingHomIsometric σ] [inst_18 : VectorBundle 𝕜₁ F₁ E₁] [inst_19 : VectorBundle 𝕜₂ F₂ E₂]
[inst_20 : MemTrivializationAtlas e₁] [inst_21 : MemTrivializationAtlas e₁'] [inst_22 : MemTrivializationAtlas e₂]
[inst_23 : MemTrivializationAtlas e₂'],
ContinuousOn (Bundle.Pretrivialization.continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂')
(e₁.baseSet ∩ e₂.baseSet ∩ (e₁'.baseSet ∩ e₂'.baseSet)) |
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_2),
(∀ (a : Batteries.RBNode.Path α) (a_3 : Batteries.RBColor) (a_4 : ℕ)
(t : Batteries.RBNode.Path.Balanced c₀ n₀ a a_3 a_4),
Batteries.RBNode.Path.Balanced.below t → motive a a_3 a_4 t) →
motive a a_1 a_2 t |
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 })
(ht.desc (CategoryTheory.Limits.BinaryCofan.mk 0 (CategoryTheory.CategoryStruct.id Y))) =
CategoryTheory.CategoryStruct.id Y |
_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 |
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 |
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.MonoidalCategoryStruct.whiskerLeft X f) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Z) |
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 |
Real.tan_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ (x : ℝ), Real.tan (Real.arccos x) = √(1 - x ^ 2) / x |
_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 |
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] →
[inst_6 : Module R B] →
[SMulCommClass R B B] →
[IsScalarTower R B B] → TensorProduct R A B →ₗ[R] TensorProduct R A B →ₗ[R] TensorProduct R A B |
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.ExponentiableMorphism f] [inst_5 : CategoryTheory.ExponentiableMorphism g]
[inst_6 : CategoryTheory.ExponentiableMorphism (CategoryTheory.CategoryStruct.comp f g)]
{Z : CategoryTheory.Functor (CategoryTheory.Over K) (CategoryTheory.Over K)}
(h :
(CategoryTheory.ChosenPullbacksAlong.pullback (CategoryTheory.CategoryStruct.comp f g)).comp
((CategoryTheory.ExponentiableMorphism.pushforward f).comp
(CategoryTheory.ExponentiableMorphism.pushforward g)) ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ExponentiableMorphism.pullbackPushforwardAdj (CategoryTheory.CategoryStruct.comp f g)).unit
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.ChosenPullbacksAlong.pullback (CategoryTheory.CategoryStruct.comp f g)).whiskerLeft
(CategoryTheory.ExponentiableMorphism.pushforwardComp f g).hom)
h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ExponentiableMorphism.pullbackPushforwardAdj (CategoryTheory.CategoryStruct.comp f g)).unit h |
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 ι],
(let __ContinuousMultilinearMap := ∑ σ, Equiv.Perm.sign σ • ContinuousMultilinearMap.domDomCongr σ 0;
{ toContinuousMultilinearMap := __ContinuousMultilinearMap, map_eq_zero_of_eq' := ⋯ }) =
0 |
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 |
BitVec.ofNat_toNat | Init.Data.BitVec.Bootstrap | ∀ {n : ℕ} (m : ℕ) (x : BitVec n), BitVec.ofNat m x.toNat = BitVec.setWidth m x |
_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 |
Lean.Elab.Term.Do.ToTerm.Kind._sizeOf_1 | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind → ℕ |
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 => p i.fst ∧ pg i.fst i.snd) fun i => sg i.fst i.snd |
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 |
_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),
(Std.DTreeMap.Internal.Impl.link k v' l' r' ⋯ ⋯).impl.Balanced |
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₀ |
WithVal.instCommRing._proof_4 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : CommRing R] (v : Valuation R Γ₀)
(x : WithVal v) (n : ℕ),
(WithVal.equiv v).toEquiv ((WithVal.equiv v).symm ((WithVal.equiv v).toEquiv x ^ n)) = (WithVal.equiv v).toEquiv x ^ n |
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.toIsometry)
(QuadraticModuleCat.ofHom e.toIsometry) =
CategoryTheory.CategoryStruct.id (QuadraticModuleCat.of Q₂) |
Batteries.CodeAction.startTacticStub | Batteries.CodeAction.Misc | Lean.CodeAction.HoleCodeAction |
PrimeMultiset.prod_dvd_prod | Mathlib.Data.PNat.Factors | ∀ {u v : PrimeMultiset}, u ≤ v → u.prod ∣ v.prod |
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) |
Lean.Lsp.DocumentColorParams.workDoneToken?._inherited_default | Lean.Data.Lsp.LanguageFeatures | Option Lean.Lsp.ProgressToken |
_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 |
Additive.subtractionMonoid._proof_1 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (x : Additive α), - -x = x |
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 |
Lean.Doc.MarkdownM.Context.inLink._default | Lean.DocString.Markdown | Bool |
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₂) →
(hi₂ : i₂ = t₁.inl) →
CategoryTheory.Limits.IsColimit t₁ →
CategoryTheory.Limits.IsColimit (t₁.pasteVert t₂ hi₂) → CategoryTheory.Limits.IsColimit t₂ |
Std.TreeSet.Raw.insert | Std.Data.TreeSet.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet.Raw α cmp → α → Std.TreeSet.Raw α cmp |
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 |
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 = ∅ |
_private.Mathlib.Order.Filter.AtTopBot.ModEq.0.Nat.frequently_even._simp_1_1 | Mathlib.Order.Filter.AtTopBot.ModEq | ∀ {n : ℕ}, Even n = (n % 2 = 0) |
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₂) |
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 |
NNReal.coe_multiset_prod | Mathlib.Data.NNReal.Basic | ∀ (s : Multiset NNReal), ↑s.prod = (Multiset.map NNReal.toReal s).prod |
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 |
imp_congr_left | Init.Core | ∀ {a b c : Prop}, (a ↔ b) → (a → c ↔ b → c) |
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 |
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 |
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 |
_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) |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.