tasksource/leandojo huggingface dataset:
Theorem: FractionalIdeal.spanSingleton_mul_coeIdeal_eq_coeIdeal
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: erw [← mk'_mul_coeIdeal_eq_coeIdeal K (IsLocalization.sec R₁⁰ z).2.prop,
  IsLocalization.mk'_sec K z]
state_before: R : Type ?u.1518060
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1518267
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I J : Ideal R₁
z : K
⊢ spanSingleton R₁⁰ z * ↑I = ↑J ↔ Ideal.span {(sec R₁⁰ z).fst} * I = Ideal.span {↑(sec R₁⁰ z).snd} * J
Theorem: inner_self_eq_norm_sq
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [pow_two, inner_self_eq_norm_mul_norm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2297537
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑re (inner x x) = ‖x‖ ^ 2
Theorem: LinearMap.comap_codRestrict
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rintro ⟨⟨_, _⟩, h, ⟨⟩⟩
state_before: R : Type u_1
R₁ : Type ?u.1019468
R₂ : Type u_3
R₃ : Type ?u.1019474
R₄ : Type ?u.1019477
S : Type ?u.1019480
K : Type ?u.1019483
K₂ : Type ?u.1019486
M : Type u_2
M' : Type ?u.1019492
M₁ : Type ?u.1019495
M₂ : Type u_4
M₃ : Type ?u.1019501
M₄ : Type ?u.1019504
N : Type ?u.1019507
N₂ : Type ?u.1019510
ι : Type ?u.1019513
V : Type ?u.1019516
V₂ : Type ?u.1019519
inst✝¹⁰ : Semiring R
inst✝⁹ : Semiring R₂
inst✝⁸ : Semiring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
p : Submodule R M
f : M₂ →ₛₗ[σ₂₁] M
hf : ∀ (c : M₂), ↑f c ∈ p
p' : Submodule R { x // x ∈ p }
x : M₂
⊢ x ∈ comap f (map (Submodule.subtype p) p') → x ∈ comap (codRestrict p f hf) p'

tactic: exact h
state_before: case intro.mk.intro.refl
R : Type u_1
R₁ : Type ?u.1019468
R₂ : Type u_3
R₃ : Type ?u.1019474
R₄ : Type ?u.1019477
S : Type ?u.1019480
K : Type ?u.1019483
K₂ : Type ?u.1019486
M : Type u_2
M' : Type ?u.1019492
M₁ : Type ?u.1019495
M₂ : Type u_4
M₃ : Type ?u.1019501
M₄ : Type ?u.1019504
N : Type ?u.1019507
N₂ : Type ?u.1019510
ι : Type ?u.1019513
V : Type ?u.1019516
V₂ : Type ?u.1019519
inst✝¹⁰ : Semiring R
inst✝⁹ : Semiring R₂
inst✝⁸ : Semiring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
p : Submodule R M
f : M₂ →ₛₗ[σ₂₁] M
hf : ∀ (c : M₂), ↑f c ∈ p
p' : Submodule R { x // x ∈ p }
x : M₂
property✝ : f.toAddHom.1 x ∈ p
h : { val := f.toAddHom.1 x, property := property✝ } ∈ ↑p'
⊢ x ∈ comap (codRestrict p f hf) p'
Theorem: CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_hom_desc
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
r s t : Cocone F
P : IsColimit s
Q : IsColimit t
⊢ ∀ (j : J), s.ι.app j ≫ (coconePointUniqueUpToIso P Q).hom ≫ desc Q r = r.ι.app j
Theorem: Finset.disjoint_map
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [disjoint_iff_ne, mem_map, exists_prop, exists_imp, and_imp]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.31419
f✝ : α ↪ β
s✝ s t : Finset α
f : α ↪ β
⊢ _root_.Disjoint (map f s) (map f t) ↔ _root_.Disjoint s t

tactic: refine' ⟨fun h a ha b hb hab => h _ _ ha rfl _ _ hb rfl <| congr_arg _ hab, _⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.31419
f✝ : α ↪ β
s✝ s t : Finset α
f : α ↪ β
⊢ (∀ (a : β) (x : α), x ∈ s → ↑f x = a → ∀ (b : β) (x : α), x ∈ t → ↑f x = b → a ≠ b) ↔
    ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b

tactic: rintro h _ a ha rfl _ b hb rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.31419
f✝ : α ↪ β
s✝ s t : Finset α
f : α ↪ β
⊢ (∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b) →
    ∀ (a : β) (x : α), x ∈ s → ↑f x = a → ∀ (b : β) (x : α), x ∈ t → ↑f x = b → a ≠ b

tactic: exact f.injective.ne (h _ ha _ hb)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.31419
f✝ : α ↪ β
s✝ s t : Finset α
f : α ↪ β
h : ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b
a : α
ha : a ∈ s
b : α
hb : b ∈ t
⊢ ↑f a ≠ ↑f b
Theorem: isAntichain_and_least_iff
File: Mathlib/Order/Antichain.lean

tactic: rintro rfl
state_before: α : Type u_1
β : Type ?u.11078
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b : α
inst✝ : Preorder α
⊢ s = {a} → IsAntichain (fun x x_1 => x ≤ x_1) s ∧ IsLeast s a

tactic: exact ⟨isAntichain_singleton _ _, isLeast_singleton⟩
state_before: α : Type u_1
β : Type ?u.11078
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
t : Set α
a b : α
inst✝ : Preorder α
⊢ IsAntichain (fun x x_1 => x ≤ x_1) {a} ∧ IsLeast {a} a
Theorem: FiniteDimensional.basisUnique.repr_eq_zero_iff
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [hv, LinearEquiv.map_zero, Finsupp.zero_apply]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
i : ι
hv : v = 0
⊢ ↑(↑(basisUnique ι h).repr v) i = 0
Theorem: PowerSeries.nat_le_order
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: by_contra H
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n : ℕ
h : ∀ (i : ℕ), i < n → ↑(coeff R i) φ = 0
⊢ ↑n ≤ order φ

tactic: rw [not_le] at H
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n : ℕ
h : ∀ (i : ℕ), i < n → ↑(coeff R i) φ = 0
H : ¬↑n ≤ order φ
⊢ False

tactic: have : (order φ).Dom := PartENat.dom_of_le_natCast H.le
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n : ℕ
h : ∀ (i : ℕ), i < n → ↑(coeff R i) φ = 0
H : order φ < ↑n
⊢ False

tactic: rw [← PartENat.natCast_get this, PartENat.coe_lt_coe] at H
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n : ℕ
h : ∀ (i : ℕ), i < n → ↑(coeff R i) φ = 0
H : order φ < ↑n
this : (order φ).Dom
⊢ False

tactic: exact coeff_order this (h _ H)
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n : ℕ
h : ∀ (i : ℕ), i < n → ↑(coeff R i) φ = 0
this : (order φ).Dom
H : Part.get (order φ) this < n
⊢ False
Theorem: Denumerable.raise_lower
File: Mathlib/Logic/Equiv/List.lean

tactic: have : n ≤ m := List.rel_of_sorted_cons h _ (l.mem_cons_self _)
state_before: α : Type ?u.45406
β : Type ?u.45409
inst✝¹ : Denumerable α
inst✝ : Denumerable β
m : ℕ
l : List ℕ
n : ℕ
h : Sorted (fun x x_1 => x ≤ x_1) (n :: m :: l)
⊢ raise (lower (m :: l) n) n = m :: l

tactic: simp [raise, lower, tsub_add_cancel_of_le this, raise_lower h.of_cons]
state_before: α : Type ?u.45406
β : Type ?u.45409
inst✝¹ : Denumerable α
inst✝ : Denumerable β
m : ℕ
l : List ℕ
n : ℕ
h : Sorted (fun x x_1 => x ≤ x_1) (n :: m :: l)
this : n ≤ m
⊢ raise (lower (m :: l) n) n = m :: l
Theorem: LocalEquiv.isImage_source_target_of_disjoint
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: rw [hs.inter_eq, ht.inter_eq, image_empty]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.31535
δ : Type ?u.31538
e : LocalEquiv α β
e'✝ : LocalEquiv β γ
e' : LocalEquiv α β
hs : Disjoint e.source e'.source
ht : Disjoint e.target e'.target
⊢ ↑e '' (e.source ∩ e'.source) = e.target ∩ e'.target
Theorem: Unitization.algHom_ext
File: Mathlib/Algebra/Algebra/Unitization.lean

tactic: ext x
state_before: S : Type u_1
R : Type u_3
A : Type u_2
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type ?u.381212
inst✝¹ : Semiring C
inst✝ : Algebra R C
φ ψ : Unitization R A →ₐ[S] B
h : ∀ (a : A), ↑φ ↑a = ↑ψ ↑a
h' : ∀ (r : R), ↑φ (↑(algebraMap R (Unitization R A)) r) = ↑ψ (↑(algebraMap R (Unitization R A)) r)
⊢ φ = ψ

tactic: induction x using Unitization.ind
state_before: case H
S : Type u_1
R : Type u_3
A : Type u_2
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type ?u.381212
inst✝¹ : Semiring C
inst✝ : Algebra R C
φ ψ : Unitization R A →ₐ[S] B
h : ∀ (a : A), ↑φ ↑a = ↑ψ ↑a
h' : ∀ (r : R), ↑φ (↑(algebraMap R (Unitization R A)) r) = ↑ψ (↑(algebraMap R (Unitization R A)) r)
x : Unitization R A
⊢ ↑φ x = ↑ψ x

tactic: simp only [map_add, ← algebraMap_eq_inl, h, h']
state_before: case H.h
S : Type u_1
R : Type u_3
A : Type u_2
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type ?u.381212
inst✝¹ : Semiring C
inst✝ : Algebra R C
φ ψ : Unitization R A →ₐ[S] B
h : ∀ (a : A), ↑φ ↑a = ↑ψ ↑a
h' : ∀ (r : R), ↑φ (↑(algebraMap R (Unitization R A)) r) = ↑ψ (↑(algebraMap R (Unitization R A)) r)
r✝ : R
a✝ : A
⊢ ↑φ (inl r✝ + ↑a✝) = ↑ψ (inl r✝ + ↑a✝)
Theorem: Metric.infDist_le_infDist_add_dist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [infDist, infDist, dist_edist]
state_before: ι : Sort ?u.61351
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infDist x s ≤ infDist y s + dist x y

tactic: refine ENNReal.toReal_le_add' infEdist_le_infEdist_add_edist ?_ (flip absurd (edist_ne_top _ _))
state_before: ι : Sort ?u.61351
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ ENNReal.toReal (infEdist x s) ≤ ENNReal.toReal (infEdist y s) + ENNReal.toReal (edist x y)

tactic: simp only [infEdist_eq_top_iff, imp_self]
state_before: ι : Sort ?u.61351
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infEdist y s = ⊤ → infEdist x s = ⊤
Theorem: MvPolynomial.coeff_monomial_mul'
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [mul_comm, mul_comm r]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
m s : σ →₀ ℕ
r : R
p : MvPolynomial σ R
⊢ coeff m (↑(monomial s) r * p) = if s ≤ m then r * coeff (m - s) p else 0

tactic: exact coeff_mul_monomial' _ _ _ _
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
m s : σ →₀ ℕ
r : R
p : MvPolynomial σ R
⊢ coeff m (p * ↑(monomial s) r) = if s ≤ m then coeff (m - s) p * r else 0
Theorem: Equiv.swapCore_self
File: Mathlib/Logic/Equiv/Basic.lean

tactic: unfold swapCore
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a : α
⊢ swapCore a a r = r

tactic: split_ifs <;> simp [*]
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a : α
⊢ (if r = a then a else if r = a then a else r) = r
Theorem: AlgebraicGeometry.RingedSpace.mem_basicOpen
File: Mathlib/AlgebraicGeometry/RingedSpace.lean

tactic: constructor
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj U.op)
x : { x // x ∈ U }
⊢ ↑x ∈ basicOpen X f ↔ IsUnit (↑(germ X.presheaf x) f)

tactic: rintro ⟨x, hx, a⟩
state_before: case mp
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj U.op)
x : { x // x ∈ U }
⊢ ↑x ∈ basicOpen X f → IsUnit (↑(germ X.presheaf x) f)

tactic: cases Subtype.eq a
state_before: case mp.intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj U.op)
x✝ x : { x // x ∈ U }
hx : x ∈ {x | IsUnit (↑(germ X.presheaf x) f)}
a : ↑x = ↑x✝
⊢ IsUnit (↑(germ X.presheaf x✝) f)

tactic: exact hx
state_before: case mp.intro.intro.refl
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj U.op)
x : { x // x ∈ U }
hx : x ∈ {x | IsUnit (↑(germ X.presheaf x) f)}
a : ↑x = ↑x
⊢ IsUnit (↑(germ X.presheaf x) f)

tactic: intro h
state_before: case mpr
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj U.op)
x : { x // x ∈ U }
⊢ IsUnit (↑(germ X.presheaf x) f) → ↑x ∈ basicOpen X f

tactic: exact ⟨x, h, rfl⟩
state_before: case mpr
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj U.op)
x : { x // x ∈ U }
h : IsUnit (↑(germ X.presheaf x) f)
⊢ ↑x ∈ basicOpen X f
Theorem: LaurentSeries.coeff_coe_powerSeries
File: Mathlib/RingTheory/LaurentSeries.lean

tactic: rw [ofPowerSeries_apply_coeff]
state_before: R : Type u
inst✝ : Semiring R
x : PowerSeries R
n : ℕ
⊢ HahnSeries.coeff (↑(ofPowerSeries ℤ R) x) ↑n = ↑(PowerSeries.coeff R n) x
Theorem: Polynomial.smul_modByMonic
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_cases hq : q.Monic
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
p✝ q : R[X]
inst✝ : Semiring S
c : R
p : R[X]
⊢ c • p %ₘ q = c • (p %ₘ q)

tactic: cases' subsingleton_or_nontrivial R with hR hR
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
p✝ q : R[X]
inst✝ : Semiring S
c : R
p : R[X]
hq : Monic q
⊢ c • p %ₘ q = c • (p %ₘ q)

tactic: simp only [eq_iff_true_of_subsingleton]
state_before: case pos.inl
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
p✝ q : R[X]
inst✝ : Semiring S
c : R
p : R[X]
hq : Monic q
hR : Subsingleton R
⊢ c • p %ₘ q = c • (p %ₘ q)

tactic: exact
(div_modByMonic_unique (c • (p /ₘ q)) (c • (p %ₘ q)) hq
    ⟨by rw [mul_smul_comm, ← smul_add, modByMonic_add_div p hq],
      (degree_smul_le _ _).trans_lt (degree_modByMonic_lt _ hq)⟩).2
state_before: case pos.inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
p✝ q : R[X]
inst✝ : Semiring S
c : R
p : R[X]
hq : Monic q
hR : Nontrivial R
⊢ c • p %ₘ q = c • (p %ₘ q)

tactic: rw [mul_smul_comm, ← smul_add, modByMonic_add_div p hq]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
p✝ q : R[X]
inst✝ : Semiring S
c : R
p : R[X]
hq : Monic q
hR : Nontrivial R
⊢ c • (p %ₘ q) + q * c • (p /ₘ q) = c • p

tactic: simp_rw [modByMonic_eq_of_not_monic _ hq]
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
p✝ q : R[X]
inst✝ : Semiring S
c : R
p : R[X]
hq : ¬Monic q
⊢ c • p %ₘ q = c • (p %ₘ q)
Theorem: PNat.gcd_eq_right_iff_dvd
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [gcd_comm]
state_before: m n : ℕ+
⊢ m ∣ n ↔ gcd n m = m

tactic: apply gcd_eq_left_iff_dvd
state_before: m n : ℕ+
⊢ m ∣ n ↔ gcd m n = m
Theorem: NonemptyInterval.coe_eq_pure
File: Mathlib/Order/Interval.lean

tactic: rw [← Interval.coe_inj, coe_pure_interval]
state_before: α : Type u_1
β : Type ?u.43617
γ : Type ?u.43620
δ : Type ?u.43623
ι : Sort ?u.43626
κ : ι → Sort ?u.43631
inst✝ : Preorder α
s : NonemptyInterval α
a : α
⊢ ↑s = Interval.pure a ↔ s = pure a
Theorem: List.sizeOf_lt_sizeOf_of_mem
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with h t ih <;> cases hx <;> rw [cons.sizeOf_spec]
state_before: ι : Type ?u.320638
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ l
⊢ sizeOf x < sizeOf l

tactic: exact lt_add_of_lt_of_nonneg (lt_one_add _) (Nat.zero_le _)
state_before: case cons.head
ι : Type ?u.320638
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ l
t : List α
ih : x ∈ t → sizeOf x < sizeOf t
⊢ sizeOf x < 1 + sizeOf x + sizeOf t

tactic: refine lt_add_of_pos_of_le ?_ (le_of_lt (ih ‹_›))
state_before: case cons.tail
ι : Type ?u.320638
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ l
h : α
t : List α
ih : x ∈ t → sizeOf x < sizeOf t
a✝ : Mem x t
⊢ sizeOf x < 1 + sizeOf h + sizeOf t

tactic: rw [add_comm]
state_before: case cons.tail
ι : Type ?u.320638
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ l
h : α
t : List α
ih : x ∈ t → sizeOf x < sizeOf t
a✝ : Mem x t
⊢ 0 < 1 + sizeOf h

tactic: exact succ_pos _
state_before: case cons.tail
ι : Type ?u.320638
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ l
h : α
t : List α
ih : x ∈ t → sizeOf x < sizeOf t
a✝ : Mem x t
⊢ 0 < sizeOf h + 1
Theorem: Real.one_sub_lt_exp_minus_of_pos
File: Mathlib/Data/Complex/Exponential.lean

tactic: cases' le_or_lt 1 y with h' h'
state_before: y : ℝ
h : 0 < y
⊢ 1 - y < exp (-y)

tactic: rw [exp_neg, lt_inv _ y.exp_pos, inv_eq_one_div]
state_before: case inr
y : ℝ
h : 0 < y
h' : y < 1
⊢ 1 - y < exp (-y)

tactic: linarith [(-y).exp_pos]
state_before: case inl
y : ℝ
h : 0 < y
h' : 1 ≤ y
⊢ 1 - y < exp (-y)

tactic: exact exp_bound_div_one_sub_of_interval' h h'
state_before: case inr
y : ℝ
h : 0 < y
h' : y < 1
⊢ exp y < 1 / (1 - y)

tactic: linarith
state_before: y : ℝ
h : 0 < y
h' : y < 1
⊢ 0 < 1 - y
Theorem: Set.Ioo.one_sub_mem
File: Mathlib/Data/Set/Intervals/Instances.lean

tactic: rw [mem_Ioo] at *
state_before: α : Type ?u.62843
inst✝¹ : StrictOrderedSemiring α
β : Type u_1
inst✝ : OrderedRing β
t : β
ht : t ∈ Ioo 0 1
⊢ 1 - t ∈ Ioo 0 1

tactic: refine' ⟨sub_pos.2 ht.2, _⟩
state_before: α : Type ?u.62843
inst✝¹ : StrictOrderedSemiring α
β : Type u_1
inst✝ : OrderedRing β
t : β
ht : 0 < t ∧ t < 1
⊢ 0 < 1 - t ∧ 1 - t < 1

tactic: exact lt_of_le_of_ne ((sub_le_self_iff 1).2 ht.1.le) (mt sub_eq_self.mp ht.1.ne')
state_before: α : Type ?u.62843
inst✝¹ : StrictOrderedSemiring α
β : Type u_1
inst✝ : OrderedRing β
t : β
ht : 0 < t ∧ t < 1
⊢ 1 - t < 1
Theorem: GaloisConnection.compose
File: Mathlib/Order/GaloisConnection.lean

tactic: intro a b
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.22803
a a₁ a₂ : α
b b₁ b₂ : β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
l1 : α → β
u1 : β → α
l2 : β → γ
u2 : γ → β
gc1 : GaloisConnection l1 u1
gc2 : GaloisConnection l2 u2
⊢ GaloisConnection (l2 ∘ l1) (u1 ∘ u2)

tactic: dsimp
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.22803
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
l1 : α → β
u1 : β → α
l2 : β → γ
u2 : γ → β
gc1 : GaloisConnection l1 u1
gc2 : GaloisConnection l2 u2
a : α
b : γ
⊢ (l2 ∘ l1) a ≤ b ↔ a ≤ (u1 ∘ u2) b

tactic: rw [gc2, gc1]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.22803
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
l1 : α → β
u1 : β → α
l2 : β → γ
u2 : γ → β
gc1 : GaloisConnection l1 u1
gc2 : GaloisConnection l2 u2
a : α
b : γ
⊢ l2 (l1 a) ≤ b ↔ a ≤ u1 (u2 b)
Theorem: ENNReal.iUnion_Icc_coe_nat
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [← Ici_inter_Iic, ← inter_iUnion, iUnion_Iic_coe_nat, diff_eq]
state_before: α : Type ?u.135385
β : Type ?u.135388
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ (⋃ (n : ℕ), Icc a ↑n) = Ici a \ {⊤}
Theorem: MonoidHom.map_zpowers
File: Mathlib/GroupTheory/Subgroup/ZPowers.lean

tactic: rw [Subgroup.zpowers_eq_closure, Subgroup.zpowers_eq_closure, f.map_closure, Set.image_singleton]
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.30840
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
x : G
⊢ Subgroup.map f (Subgroup.zpowers x) = Subgroup.zpowers (↑f x)
Theorem: List.unzip_zip_left
File: Mathlib/Data/List/Zip.lean

tactic: rw [eq_nil_of_length_eq_zero (Nat.eq_zero_of_le_zero h)]
state_before: α : Type u
β : Type u_1
γ : Type ?u.86201
δ : Type ?u.86204
ε : Type ?u.86207
l₁ : List α
h : length l₁ ≤ length []
⊢ (unzip (zip l₁ [])).fst = l₁

tactic: rfl
state_before: α : Type u
β : Type u_1
γ : Type ?u.86201
δ : Type ?u.86204
ε : Type ?u.86207
l₁ : List α
h : length l₁ ≤ length []
⊢ (unzip (zip [] [])).fst = []

tactic: simp only [zip_cons_cons, unzip_cons, unzip_zip_left (le_of_succ_le_succ h)]
state_before: α : Type u
β : Type u_1
γ : Type ?u.86201
δ : Type ?u.86204
ε : Type ?u.86207
a : α
l₁ : List α
b : β
l₂ : List β
h : length (a :: l₁) ≤ length (b :: l₂)
⊢ (unzip (zip (a :: l₁) (b :: l₂))).fst = a :: l₁
Theorem: point_disjoint_finset_opens_of_t2
File: Mathlib/Topology/Separation.lean

tactic: exact_mod_cast finset_disjoint_finset_opens_of_t2 {x} s (Finset.disjoint_singleton_left.mpr h)
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.129204
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
x : α
s : Finset α
h : ¬x ∈ s
⊢ SeparatedNhds {x} ↑s
Theorem: Matrix.vec_one_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.899745
m : Type u_1
n : Type u_2
o : Type ?u.899754
m' : o → Type ?u.899759
n' : o → Type ?u.899764
R : Type ?u.899767
S : Type ?u.899770
α : Type v
β : Type w
γ : Type ?u.899777
inst✝¹ : NonAssocSemiring α
inst✝ : Fintype m
A : Matrix m n α
⊢ vecMul 1 A = fun j => ∑ i : m, A i j

tactic: simp [vecMul, dotProduct]
state_before: case h
l : Type ?u.899745
m : Type u_1
n : Type u_2
o : Type ?u.899754
m' : o → Type ?u.899759
n' : o → Type ?u.899764
R : Type ?u.899767
S : Type ?u.899770
α : Type v
β : Type w
γ : Type ?u.899777
inst✝¹ : NonAssocSemiring α
inst✝ : Fintype m
A : Matrix m n α
x✝ : n
⊢ vecMul 1 A x✝ = ∑ i : m, A i x✝
Theorem: List.nodup_ofFn_ofInjective
File: Mathlib/Data/List/FinRange.lean

tactic: rw [ofFn_eq_pmap]
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
hf : Function.Injective f
⊢ Nodup (ofFn f)

tactic: exact (nodup_range n).pmap fun _ _ _ _ H => Fin.veq_of_eq <| hf H
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
hf : Function.Injective f
⊢ Nodup (pmap (fun i hi => f { val := i, isLt := hi }) (range n) (_ : ∀ (x : ℕ), x ∈ range n → x < n))