name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Rat.Lemmas.0.Rat.le_iff_lt_or_eq._simp_1_1 | Init.Data.Rat.Lemmas | ∀ (a b : ℚ), (a ≤ b) = (a.num * ↑b.den ≤ b.num * ↑a.den) | null | false |
Std.Do.ExceptConds.imp | Std.Do.PostCond | {ps : Std.Do.PostShape} → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps | Implication of exception assertions is defined as pointwise implication of the assertion for each
exception.
Unlike entailment (`ExceptConds.entails`), which is an ordinary proposition of type `Prop`,
implication of exception assertions is itself an exception assertion.
| true |
T5Space | Mathlib.Topology.Separation.Regular | (X : Type u) → [TopologicalSpace X] → Prop | A T₅ space is a completely normal T₁ space. | true |
NumberField.InfinitePlace.embedding_of_isReal._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] {w : NumberField.InfinitePlace K},
w.IsReal → NumberField.ComplexEmbedding.IsReal w.embedding | null | false |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.finite_setOfPred_matroid._simp_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
EMetric.tendsto_nhds | Mathlib.Topology.EMetricSpace.Defs | ∀ {β : Type v} {α : Type u_2} [inst : PseudoEMetricSpace α] {f : Filter β} {u : β → α} {a : α},
Filter.Tendsto u f (nhds a) ↔ ∀ ε > 0, ∀ᶠ (x : β) in f, edist (u x) a < ε | null | true |
IsCompact.isClosed_image_restrict | Mathlib.Topology.IsClosedRestrict | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ((i : ι) → α i)} [inst : (i : ι) → TopologicalSpace (α i)] (S : Set ι),
IsCompact s → IsClosed s → IsClosed (S.domRestrict '' s) | The restriction of a compact closed set in a product space to a set of coordinates is closed. | true |
IsCompact.elim_directed_cover | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {ι : Type v} [hι : Nonempty ι],
IsCompact s →
∀ (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → Directed (fun x1 x2 => x1 ⊆ x2) U → ∃ i, s ⊆ U i | For every open directed cover of a compact set, there exists a single element of the
cover which itself includes the set. | true |
UpperSet.compl_map | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) (s : UpperSet α),
((UpperSet.map f) s).compl = (LowerSet.map f) s.compl | null | true |
BooleanAlgebra.himp_eq._autoParam | Mathlib.Order.BooleanAlgebra.Defs | Lean.Syntax | null | false |
SimpleGraph.isClique_map_iff_of_nontrivial | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {f : α ↪ β} {t : Set β},
t.Nontrivial → ((SimpleGraph.map (⇑f) G).IsClique t ↔ ∃ s, G.IsClique s ∧ ⇑f '' s = t) | null | true |
CategoryTheory.Grothendieck.preEquivalence._simp_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {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) | null | false |
List.bidirectionalRec.eq_2 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} {motive : List α → Sort u_2} (nil : motive []) (singleton : (a : α) → motive [a])
(cons_append : (a : α) → (l : List α) → (b : α) → motive l → motive (a :: (l ++ [b]))) (a : α),
List.bidirectionalRec nil singleton cons_append [a] = singleton a | null | true |
DihedralGroup.oddCommuteEquiv.match_7 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (motive : ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n → Prop) (x : ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n),
(∀ (val : ZMod n), motive (Sum.inl val)) →
(∀ (val : ZMod n), motive (Sum.inr (Sum.inl val))) →
(∀ (k : ZMod n), motive (Sum.inr (Sum.inr (Sum.inl k)))) →
(∀ (fst snd : ZMod n), m... | null | false |
Finsupp.subset_mapRange_neLocus | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N]
[inst_3 : DecidableEq M] [inst_4 : Zero M] (f g : α →₀ N) {F : N → M} (F0 : F 0 = 0),
(Finsupp.mapRange F F0 f).neLocus (Finsupp.mapRange F F0 g) ⊆ f.neLocus g | null | true |
CategoryTheory.ShortComplex.ShortExact.injective_f | Mathlib.Algebra.Homology.ShortComplex.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.HasForget₂ C Ab] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : (CategoryTheory.forge... | null | true |
List.span.loop._sunfold | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → List α → List α × List α | null | false |
Units.instRepr.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] [inst_1 : Repr α], Units.instRepr = { reprPrec := reprPrec ∘ Units.val } | null | true |
Real.exists_int_int_abs_mul_sub_le | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ (ξ : ℝ) {n : ℕ}, 0 < n → ∃ j k, 0 < k ∧ k ≤ ↑n ∧ |↑k * ξ - ↑j| ≤ 1 / (↑n + 1) | *Dirichlet's approximation theorem:*
For any real number `ξ` and positive natural `n`, there are integers `j` and `k`,
with `0 < k ≤ n` and `|k*ξ - j| ≤ 1/(n+1)`.
See also `Real.exists_nat_abs_mul_sub_round_le`. | true |
Complex.circleIntegral_sub_center_inv_smul_of_differentiable_on_off_countable | Mathlib.Analysis.Complex.CauchyIntegral | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [CompleteSpace E] {R : ℝ},
0 < R →
∀ {f : ℂ → E} {c : ℂ} {s : Set ℂ},
s.Countable →
ContinuousOn f (Metric.closedBall c R) →
(∀ z ∈ Metric.ball c R \ s, DifferentiableAt ℂ f z) →
∮ (z : ℂ) in C(c, R), (z - ... | **Cauchy integral formula** for the value at the center of a disc. If `f : ℂ → E` is continuous on a
closed disc of radius `R` and center `c`, and is complex differentiable at all but countably many
points of its interior, then the integral $\oint_{|z-c|=R} \frac{f(z)}{z-c}\,dz$ is equal to
`2πi • f c`.
| true |
CochainComplex.Plus._proof_1 | Mathlib.Algebra.Homology.CochainComplexPlus | IsRightCancelAdd ℤ | null | false |
Lean.Meta.Grind.PreInstance.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ (proof : Lean.Expr) (assignment : Array Lean.Expr) (proof_1 : Lean.Expr) (assignment_1 : Array Lean.Expr),
({ proof := proof, assignment := assignment } = { proof := proof_1, assignment := assignment_1 }) =
(proof = proof_1 ∧ assignment = assignment_1) | null | true |
SimpleGraph.replaceVertex._proof_1 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u_1} (G : SimpleGraph V) (s t : V) [inst : DecidableEq V],
Std.Symm fun v w => if v = t then if w = t then False else G.Adj s w else if w = t then G.Adj v s else G.Adj v w | null | false |
Multiset.sum_zero | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_2} [inst : AddCommMonoid M], Multiset.sum 0 = 0 | null | true |
LinearMap.map_dfinsuppSumAddHom | Mathlib.LinearAlgebra.DFinsupp | ∀ {R : Type u_7} {R₂ : Type u_8} {M : Type u_9} {M₂ : Type u_10} {ι : Type u_11} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {σ₁₂ : R →+* R₂} [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {γ : ι → Type u_12} [inst_6 : DecidableEq ι] [inst_7 : (i : ι) → AddZeroCl... | null | true |
MeasureTheory.isSetAlgebra_generateSetAlgebra | Mathlib.MeasureTheory.SetAlgebra | ∀ {α : Type u_1} {𝒜 : Set (Set α)}, MeasureTheory.IsSetAlgebra (MeasureTheory.generateSetAlgebra 𝒜) | The algebra of sets generated by a family of sets is an algebra of sets. | true |
Lean.Grind.CommRing.Expr.denoteSAsRing | Init.Grind.Ring.CommSemiringAdapter | {α : Type u_1} →
[inst : Lean.Grind.Semiring α] →
Lean.Grind.CommRing.Context α → Lean.Grind.CommRing.Expr → Lean.Grind.Ring.OfSemiring.Q α | null | true |
NonarchAddGroupNorm.coe_le_coe._simp_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : NonarchAddGroupNorm E}, (⇑p ≤ ⇑q) = (p ≤ q) | null | false |
Homeomorph.mulRight.congr_simp | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : SeparatelyContinuousMul G] (a a_1 : G),
a = a_1 → Homeomorph.mulRight a = Homeomorph.mulRight a_1 | null | true |
Lean.Parser.Command.whereStructInst.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
OrderDual.gradeOrder._proof_2 | Mathlib.Order.Grade | ∀ {𝕆 : Type u_2} {α : Type u_1} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α] (x x_1 : αᵒᵈ),
x ⋖ x_1 → OrderDual.toDual (grade 𝕆 (OrderDual.ofDual x)) ⋖ OrderDual.toDual (grade 𝕆 (OrderDual.ofDual x_1)) | null | false |
WeakSpace.instContinuousSMul | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | ∀ {𝕜 : Type u_2} {E : Type u_4} [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E]
[ContinuousSMul 𝕜 𝕜], ContinuousSMul 𝕜 (WeakSpace 𝕜 E) | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Assignment.0.Std.Tactic.BVDecide.LRAT.Internal.Assignment.ofClause.match_1.splitter | Std.Tactic.BVDecide.LRAT.Internal.Assignment | (motive : Option Bool → Sort u_1) →
(x : Option Bool) →
((value : Bool) → motive (some value)) →
((x : Option Bool) → (∀ (value : Bool), x = some value → False) → motive x) → motive x | null | true |
Std.Rci.HasRcoIntersection.casesOn | Init.Data.Range.Polymorphic.PRange | {α : Type w} →
{motive : Std.Rci.HasRcoIntersection α → Sort u} →
(t : Std.Rci.HasRcoIntersection α) →
((intersection : Std.Rci α → Std.Rco α → Std.Rco α) → motive { intersection := intersection }) → motive t | null | false |
IsDenseInducing.closure_image_mem_nhds | Mathlib.Topology.DenseEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β} {s : Set α}
{a : α}, IsDenseInducing i → s ∈ nhds a → closure (i '' s) ∈ nhds (i a) | null | true |
Con.mapOfSurjective | Mathlib.GroupTheory.Congruence.Hom | {M : Type u_1} →
{N : Type u_2} →
{F : Type u_4} →
[inst : Mul M] →
[inst_1 : Mul N] →
[inst_2 : FunLike F M N] →
[inst_3 : MulHomClass F M N] → {c : Con M} → (f : F) → Con.ker f ≤ c → Function.Surjective ⇑f → Con N | Given a surjective multiplicative-preserving function `f` whose kernel is contained in a
congruence relation `c`, the congruence relation on `f`'s codomain defined by '`x ≈ y` iff the
elements of `f⁻¹(x)` are related to the elements of `f⁻¹(y)` by `c`.' | true |
Nat.le.intro | Init.Data.Nat.Basic | ∀ {n m k : ℕ}, n + k = m → n ≤ m | null | true |
Subgroup.IsSubnormal.eq_bot_or_top_of_isSimpleGroup | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, IsSimpleGroup G → H.IsSubnormal → H = ⊥ ∨ H = ⊤ | A subnormal subgroup of a simple group is either trivial or the whole group. | true |
_private.Mathlib.Data.Num.ZNum.0.ZNum.bit0_of_bit0.match_1_1 | Mathlib.Data.Num.ZNum | ∀ (motive : ZNum → Prop) (x : ZNum),
(∀ (_ : Unit), motive ZNum.zero) →
(∀ (a : PosNum), motive (ZNum.pos a)) → (∀ (a : PosNum), motive (ZNum.neg a)) → motive x | null | false |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.map._proof_8 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {X : CategoryTheory.SimplicialObject.Augmented C}
(ed : X.ExtraDegeneracy) (F : CategoryTheory.Functor C D) (n : ℕ) (i : Fin (n + 2)),
CategoryTheory.CategoryStruct.comp (F.map (ed.s (n + ... | null | false |
Filter.comap._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {β : Type u_2} (m : α → β) (f : Filter β) {x y : Set α},
x ∈ {s | ∃ t ∈ f, m ⁻¹' t ⊆ s} → y ∈ {s | ∃ t ∈ f, m ⁻¹' t ⊆ s} → x ∩ y ∈ {s | ∃ t ∈ f, m ⁻¹' t ⊆ s} | null | false |
Multiset.coe_eq_coe | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {l₁ l₂ : List α}, ↑l₁ = ↑l₂ ↔ l₁.Perm l₂ | null | true |
_private.Lean.DocString.Add.0.Lean.makeDocStringVerso._sparseCasesOn_1 | Lean.DocString.Add | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
PointedCone.mem_span | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_5} [inst : Ring R] [inst_1 : PartialOrder R] [IsDirectedOrder R] [inst_3 : IsOrderedRing R] {E : Type u_6}
[inst_4 : AddCommGroup E] [inst_5 : Module R E] {C : PointedCone R E} {x : E},
x ∈ Submodule.span R ↑C ↔ ∃ p ∈ C, ∃ n ∈ C, x = p - n | null | true |
Valuation.Uniformizer._sizeOf_1 | Mathlib.RingTheory.Valuation.Discrete.Basic | {Γ : Type u_1} →
{inst : LinearOrderedCommGroupWithZero Γ} →
{A : Type u_2} →
{inst_1 : Ring A} → {v : Valuation A Γ} → {hv : v.IsRankOneDiscrete} → [SizeOf Γ] → [SizeOf A] → v.Uniformizer → ℕ | null | false |
Equiv.sigmaSigmaSubtype._proof_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_2} {β : α → Type u_3} {γ : (a : α) → β a → Type u_1} (p : (a : α) × β a → Prop),
{ s // p ⟨s.fst, s.snd.fst⟩ } = { s // p ⟨s.fst, s.snd.fst⟩ } | null | false |
Bool.compl_eq_bnot | Mathlib.Order.BooleanAlgebra.Defs | compl = not | null | true |
True | Init.Prelude | Prop | `True` is a proposition and has only an introduction rule, `True.intro : True`.
In other words, `True` is simply true, and has a canonical proof, `True.intro`
For more information: [Propositional Logic](https://lean-lang.org/theorem_proving_in_lean4/propositions_and_proofs.html#propositional-logic)
| true |
String.Slice.utf8ByteSize_sliceTo | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, (s.sliceTo pos).utf8ByteSize = pos.offset.byteIdx | null | true |
LinearMap.compl₂._proof_2 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_9} {R₂ : Type u_7} {R₃ : Type u_4} {R₄ : Type u_3} {R₅ : Type u_6} {M : Type u_8} {N : Type u_5}
{P : Type u_1} {Q : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : Semiring R₄]
[inst_4 : Semiring R₅] {σ₂₃ : R₂ →+* R₃} {σ₄₂ : R₄ →+* R₂} {σ₄₃ : R₄ →+* R₃} [inst_5 :... | null | false |
Lean.CollectFVars.visit | Lean.Util.CollectFVars | Lean.Expr → Lean.CollectFVars.Visitor | null | true |
Hypergraph._sizeOf_inst | Mathlib.Combinatorics.Hypergraph.Basic | (α : Type u_4) → [SizeOf α] → SizeOf (Hypergraph α) | null | false |
Multiset.singleton_ne_zero | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (a : α), {a} ≠ 0 | null | true |
IsUniformAddGroup.casesOn | Mathlib.Topology.Algebra.IsUniformGroup.Defs | {α : Type u_3} →
[inst : UniformSpace α] →
[inst_1 : AddGroup α] →
{motive : IsUniformAddGroup α → Sort u} →
(t : IsUniformAddGroup α) →
((uniformContinuous_sub : UniformContinuous fun p => p.1 - p.2) → motive ⋯) → motive t | null | false |
GroupExtension.Equiv.ofMonoidHom.eq_1 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (f : E →* E')
(comp_inl : f.comp S.inl = S'.inl) (rightHom_comp : S'.rightHom.comp f = S.rightHom),
GroupExtension.Equiv... | null | true |
Turing.PartrecToTM2.codeSupp'.match_1 | Mathlib.Computability.TuringMachine.ToPartrec | (motive : Turing.ToPartrec.Code → Turing.PartrecToTM2.Cont' → Sort u_1) →
(x : Turing.ToPartrec.Code) →
(x_1 : Turing.PartrecToTM2.Cont') →
((c : Turing.ToPartrec.Code) →
(h : c = Turing.ToPartrec.Code.zero') →
(k : Turing.PartrecToTM2.Cont') → motive (namedPattern c Turing.ToPartrec.C... | null | false |
Lean.Lsp.ReferenceContext | Lean.Data.Lsp.LanguageFeatures | Type | null | true |
_private.Init.Data.Int.Gcd.0.Int.gcd_le_right._proof_1_1 | Init.Data.Int.Gcd | ∀ {b : ℤ}, 0 < b → ¬b = ↑b.natAbs → False | null | false |
Std.HashSet.isEmpty_eq_size_eq_zero | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α}, m.isEmpty = (m.size == 0) | null | true |
Tilt.instField._aux_8 | Mathlib.RingTheory.Perfection | (K : Type u_1) →
[inst : Field K] →
(v : Valuation K NNReal) →
(O : Type u_2) →
[inst_1 : CommRing O] →
[inst_2 : Algebra O K] →
(hv : v.Integers O) →
(p : ℕ) →
[inst_3 : Fact (Nat.Prime p)] →
[hvp : Fact (v ↑p ≠ 1)] → Fact ¬IsUni... | null | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory.0.MeasureTheory.exists_lt_lowerSemicontinuous_integral_lt._simp_1_7 | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ (x : ENNReal), (↑x = ⊥) = False | null | false |
Std.IterM.DefaultConsumers.forIn_eq | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {γ : Type x} {α β : Type w} {m : Type w → Type w'} {n : Type x → Type x'} [inst : Monad n]
[inst_1 : Std.Iterator α m β] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ}
{plausible_forInStep : β → γ → ForInStep γ → Prop} {it : Std.IterM m β} {init : γ}
{f : (b : β) → it.IsPlausibleIndirectOutput b →... | null | true |
Nat.gcd_self | Init.Data.Nat.Gcd | ∀ (n : ℕ), n.gcd n = n | null | true |
Subgroup.IsComplement.toRightFun.eq_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {T : Set G} (hT : Subgroup.IsComplement (↑H) T),
hT.toRightFun = ⇑hT.rightQuotientEquiv ∘ Quotient.mk'' | null | true |
_private.Mathlib.Geometry.Manifold.HasGroupoid.0.restr_mem_maximalAtlas_aux1 | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(G : StructureGroupoid H) [ClosedUnderRestriction G] {e e' : OpenPartialHomeomorph M H},
e ∈ StructureGroupoid.maximalAtlas M G → e' ∈ atlas H M → ∀ {s : Set M}, IsOpen s → (e.restr s).symm.trans e' ∈... | null | true |
Lean.Meta.SynthInstance.State.generatorStack._default | Lean.Meta.SynthInstance | Array Lean.Meta.SynthInstance.GeneratorNode | null | false |
BitVec.toFin_ofFnLEAux | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (m : ℕ) (f : Fin n → Bool), (BitVec.ofFnLEAux m f).toFin = Fin.ofNat (2 ^ m) (Nat.ofBits f) | null | true |
_private.Mathlib.Topology.Constructions.0.inducing_sigma.match_1_2 | Mathlib.Topology.Constructions | ∀ {ι : Type u_1} {σ : ι → Type u_2} (motive : Sigma σ → Prop) (x : Sigma σ),
(∀ (i : ι) (x : σ i), motive ⟨i, x⟩) → motive x | null | false |
Finset.compls.eq_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α], Finset.compls = Finset.map { toFun := compl, inj' := ⋯ } | null | true |
one_le_pow₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [ZeroLEOneClass M₀] [PosMulMono M₀],
1 ≤ a → ∀ {n : ℕ}, 1 ≤ a ^ n | null | true |
CategoryTheory.LocallyDiscrete.eqToHom_toLoc | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {a b : C} (h : a = b),
(CategoryTheory.eqToHom h).toLoc = CategoryTheory.eqToHom ⋯ | null | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.exact₂_iff._proof_1_10 | Mathlib.Algebra.Homology.ExactSequence | ∀ (i : ℕ), i + 2 ≤ 2 → i = 0 | null | false |
isClosed_coinduced | Mathlib.Topology.Order | ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}, IsClosed s ↔ IsClosed (f ⁻¹' s) | null | true |
Finite.exists_max | Mathlib.Data.Fintype.Lattice | ∀ {α : Type u_2} {β : Type u_3} [Finite α] [Nonempty α] [inst : LinearOrder β] (f : α → β), ∃ x₀, ∀ (x : α), f x ≤ f x₀ | null | true |
CategoryTheory.NatTrans.IsMonoidal.casesOn | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F₁ F₂ : CategoryTheory.Functor C D} →
{τ : ... | null | false |
Lean.Grind.CommRing.Expr.denoteSAsRing.eq_2 | Init.Grind.Ring.CommSemiringAdapter | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (k : ℕ),
Lean.Grind.CommRing.Expr.denoteSAsRing ctx (Lean.Grind.CommRing.Expr.natCast k) = OfNat.ofNat k | null | true |
Std.DTreeMap.Raw.isSome_getKey?_iff_mem._simp_1 | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, ((t.getKey? a).isSome = true) = (a ∈ t) | null | false |
Lean.Elab.Term.SavedContext.recOn | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.SavedContext → Sort u} →
(t : Lean.Elab.Term.SavedContext) →
((declName? : Option Lean.Name) →
(options : Lean.Options) →
(openDecls : List Lean.OpenDecl) →
(macroStack : Lean.Elab.MacroStack) →
(errToSorry : Bool) →
(levelNames ... | null | false |
MonotoneOn.slope_nonneg | Mathlib.LinearAlgebra.AffineSpace.Slope | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : AddCommGroup E] [inst_2 : Module k E]
[inst_3 : LinearOrder k] [IsStrictOrderedRing k] [inst_5 : PartialOrder E] [IsOrderedAddMonoid E] [PosSMulMono k E]
{f : k → E} {x y : k} {s : Set k}, MonotoneOn f s → x ∈ s → y ∈ s → 0 ≤ slope f x y | null | true |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps.«term_⊗ₘ_» | Mathlib.RingTheory.Coalgebra.CoassocSimps | Lean.TrailingParserDescr | null | true |
ge_of_tendsto | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [ClosedIciTopology α] {f : β → α}
{a b : α} {x : Filter β} [hx : x.NeBot], Filter.Tendsto f x (nhds a) → (∀ᶠ (c : β) in x, b ≤ f c) → b ≤ a | null | true |
AffineSubspace.dim_le_zero_iff_subsingleton._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Dimension | ∀ {R : Type u} {V : Type v} {A : Type a} [inst : AddCommGroup V] [inst_1 : AddTorsor V A] [inst_2 : Ring R]
[inst_3 : Module R V] {s : AffineSubspace R A} [IsDomain R] [Module.IsTorsionFree R ↥s.direction],
(s.dim ≤ 0) = (↑s).Subsingleton | null | false |
UniformCauchySeqOnFilter.eq_1 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : UniformSpace β] (F : ι → α → β) (p : Filter ι) (p' : Filter α),
UniformCauchySeqOnFilter F p p' =
∀ u ∈ uniformity β, ∀ᶠ (m : (ι × ι) × α) in (p ×ˢ p) ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u | null | true |
CategoryTheory.ExactFunctor.whiskeringRight_obj_map | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ (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 : D ⥤ₑ E) {X Y : C ⥤ₑ D} (f : X ⟶ Y),
((CategoryTheory.ExactFunctor.whiskeringRight C D E).obj F).map f =
CategoryTheory.ObjectPr... | null | true |
ContinuousCohomology.π | Mathlib.RepresentationTheory.Homological.ContCohomology.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : Ring k] →
[inst_1 : Group G] →
[inst_2 : TopologicalSpace k] →
[inst_3 : TopologicalSpace G] →
[inst_4 : IsTopologicalGroup G] →
(A : TopRep k G) →
(n : ℕ) →
HomologicalComplex.cycles A.ho... | The natural map from `n`-cocycles to `n`th continuous cohomology for a `k`-linear
`G`-representation `A`. | true |
HasFTaylorSeriesUpTo.hasFDerivAt | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
HasFTaylorSeriesUpTo n f p → n ≠ 0 → ∀ (x :... | If a function has a Taylor series at order at least `1`, then the term of order `1` of this
series is a derivative of `f`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_of_getKey?_eq_some._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.Topology.Order.Monotone.0.MonotoneOn.countable_setOfPred_two_preimages._simp_1_6 | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) | null | false |
FirstOrder.Language.StrongHomClass.realize_formula._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {α : Type u'}
{F : Type u_4} [inst_2 : EquivLike F M N] [L.StrongHomClass F M N] (g : F) (φ : L.Formula α) {v : α → M},
φ.Realize (⇑g ∘ v) = φ.Realize v | null | false |
_private.Mathlib.SetTheory.Ordinal.Topology.0.Ordinal.mem_closure_tfae._simp_1_2 | Mathlib.SetTheory.Ordinal.Topology | ∀ {α : Type u_1} [inst : SupSet α] (s : Set α), ⨆ a, ↑a = sSup s | null | false |
Aesop.RuleTac.ForwardM.instInhabitedState | Aesop.RuleTac.Forward | Inhabited Aesop.RuleTac.ForwardM.State | null | true |
CliffordAlgebra.map_comp_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [inst_1 : AddCommGroup M₁]
[inst_2 : AddCommGroup M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {Q₁ : QuadraticForm R M₁}
{Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂),
(CliffordAlgebra.map f).toLinearMap ∘ₗ CliffordAlgebra.ι Q₁ = CliffordAlgebr... | null | true |
_private.Mathlib.Algebra.Lie.Basis.Prod.0.LieAlgebra.Basis.prodCartanEquiv._proof_5 | Mathlib.Algebra.Lie.Basis.Prod | ∀ {ι₁ : Type u_3} {L₁ : Type u_1} [inst : Finite ι₁] [inst_1 : LieRing L₁] {R : Type u_2} [inst_2 : CommRing R]
[inst_3 : LieAlgebra R L₁] {H₁ : LieSubalgebra R L₁} (b₁ : LieAlgebra.Basis ι₁ H₁),
(LieSubalgebra.lieSpan R L₁ (Set.range b₁.h)).toSubmodule = Submodule.span R (Set.range b₁.h) | null | false |
TopCat.of.sizeOf_spec | Mathlib.Topology.Category.TopCat.Basic | ∀ (carrier : Type u) [str : TopologicalSpace carrier], sizeOf ↧carrier = 1 + sizeOf carrier + sizeOf str | null | true |
_private.Mathlib.Algebra.Group.Submonoid.Support.0.AddSubgroup.gc_toAddSubmonoid_support._proof_1_1 | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_1} [inst : AddGroup G] (x : AddSubgroup G) (x_1 : AddSubmonoid G),
x.toAddSubmonoid ≤ x_1 ↔ x.toAddSubmonoid ≤ x_1.support.toAddSubmonoid | null | false |
instCommutativeInt8HAnd | Init.Data.SInt.Bitwise | Std.Commutative fun x1 x2 => x1 &&& x2 | null | true |
_private.Lean.Meta.Constructions.NoConfusion.0.Lean.mkNoConfusionType._sparseCasesOn_1 | Lean.Meta.Constructions.NoConfusion | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Int.dvd_mul_gcd_iff_dvd_mul | Init.Data.Int.Gcd | ∀ {k n m : ℤ}, k ∣ n * ↑(k.gcd m) ↔ k ∣ n * m | null | true |
Turing.TM1.Stmt.brecOn | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
{motive : Turing.TM1.Stmt Γ Λ σ → Sort u} →
(t : Turing.TM1.Stmt Γ Λ σ) → ((t : Turing.TM1.Stmt Γ Λ σ) → Turing.TM1.Stmt.below t → motive t) → motive t | null | false |
Finset.exists_ne_map_eq_of_card_image_lt | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} [inst : DecidableEq β] {f : α → β},
(Finset.image f s).card < s.card → ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ f x = f y | a special case of `Finset.exists_ne_map_eq_of_card_lt_of_maps_to` where `t` is `s.image f` | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.