tasksource/leandojo huggingface dataset:
Theorem: Multiset.sigma_add
File: Mathlib/Data/Multiset/Bind.lean

tactic: rw [cons_sigma, IH]
state_before: α : Type u_2
β : Type ?u.71688
γ : Type ?u.71691
δ : Type ?u.71694
σ : α → Type u_1
a✝ : α
s✝ : Multiset α
t✝ : (a : α) → Multiset (σ a)
a : α
s : Multiset α
IH : ∀ (t u : (a : α) → Multiset (σ a)), (Multiset.sigma s fun a => t a + u a) = Multiset.sigma s t + Multiset.sigma s u
t u : (a : α) → Multiset (σ a)
⊢ (Multiset.sigma (a ::ₘ s) fun a => t a + u a) = Multiset.sigma (a ::ₘ s) t + Multiset.sigma (a ::ₘ s) u

tactic: simp [add_comm, add_left_comm, add_assoc]
state_before: α : Type u_2
β : Type ?u.71688
γ : Type ?u.71691
δ : Type ?u.71694
σ : α → Type u_1
a✝ : α
s✝ : Multiset α
t✝ : (a : α) → Multiset (σ a)
a : α
s : Multiset α
IH : ∀ (t u : (a : α) → Multiset (σ a)), (Multiset.sigma s fun a => t a + u a) = Multiset.sigma s t + Multiset.sigma s u
t u : (a : α) → Multiset (σ a)
⊢ map (Sigma.mk a) (t a + u a) + ((Multiset.sigma s fun a => t a) + Multiset.sigma s fun a => u a) =
    Multiset.sigma (a ::ₘ s) t + Multiset.sigma (a ::ₘ s) u
Theorem: SimplexCategory.len_lt_of_mono
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: rcases lt_or_eq_of_le (len_le_of_mono hi) with (h | h)
state_before: Δ' Δ : SimplexCategory
i : Δ' ⟶ Δ
hi : Mono i
hi' : Δ ≠ Δ'
⊢ len Δ' < len Δ

tactic: exact h
state_before: case inl
Δ' Δ : SimplexCategory
i : Δ' ⟶ Δ
hi : Mono i
hi' : Δ ≠ Δ'
h : len Δ' < len Δ
⊢ len Δ' < len Δ

tactic: exfalso
state_before: case inr
Δ' Δ : SimplexCategory
i : Δ' ⟶ Δ
hi : Mono i
hi' : Δ ≠ Δ'
h : len Δ' = len Δ
⊢ len Δ' < len Δ

tactic: exact hi' (by ext ; exact h.symm)
state_before: case inr.h
Δ' Δ : SimplexCategory
i : Δ' ⟶ Δ
hi : Mono i
hi' : Δ ≠ Δ'
h : len Δ' = len Δ
⊢ False

tactic: ext
state_before: Δ' Δ : SimplexCategory
i : Δ' ⟶ Δ
hi : Mono i
hi' : Δ ≠ Δ'
h : len Δ' = len Δ
⊢ Δ = Δ'

tactic: exact h.symm
state_before: case a
Δ' Δ : SimplexCategory
i : Δ' ⟶ Δ
hi : Mono i
hi' : Δ ≠ Δ'
h : len Δ' = len Δ
⊢ len Δ = len Δ'
Theorem: Nat.add_mod_mod
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.add_comm, mod_add_mod, Nat.add_comm]
state_before: m n k : Nat
⊢ (m + n % k) % k = (m + n) % k
Theorem: Substring.Valid.atEnd
File: Std/Data/String/Lemmas.lean

tactic: simp [h.atEnd, h.toString]
state_before: p : Nat
x✝ : Substring
h✝ : Valid x✝
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ Substring.atEnd x✝ { byteIdx := p } = true ↔ p = utf8ByteSize (toString x✝)
Theorem: SemiconjBy.sub_left
File: Mathlib/Algebra/Ring/Semiconj.lean

tactic: simpa only [sub_eq_add_neg] using ha.add_left hb.neg_left
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing R
a b x y x' y' : R
ha : SemiconjBy a x y
hb : SemiconjBy b x y
⊢ SemiconjBy (a - b) x y
Theorem: card_classGroup_eq_one
File: Mathlib/RingTheory/ClassGroup.lean

tactic: rw [Fintype.card_eq_one_iff]
state_before: R : Type u_1
K : Type ?u.1948840
L : Type ?u.1948843
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
⊢ Fintype.card (ClassGroup R) = 1

tactic: use 1
state_before: R : Type u_1
K : Type ?u.1948840
L : Type ?u.1948843
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
⊢ ∃ x, ∀ (y : ClassGroup R), y = x

tactic: refine ClassGroup.induction (R := R) (FractionRing R) (fun I => ?_)
state_before: R : Type u_1
K : Type ?u.1948840
L : Type ?u.1948843
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
⊢ ∀ (y : ClassGroup R), y = 1

tactic: exact ClassGroup.mk_eq_one_iff.mpr (I : FractionalIdeal R⁰ (FractionRing R)).isPrincipal
state_before: R : Type u_1
K : Type ?u.1948840
L : Type ?u.1948843
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
⊢ ↑ClassGroup.mk I = 1
Theorem: Matrix.mul_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.380296
m : Type u_1
n : Type u_2
o : Type u_3
m' : o → Type ?u.380310
n' : o → Type ?u.380315
R : Type ?u.380318
S : Type ?u.380321
α : Type v
β : Type w
γ : Type ?u.380328
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
⊢ M ⬝ (-N) = -M ⬝ N

tactic: apply dotProduct_neg
state_before: case a.h
l : Type ?u.380296
m : Type u_1
n : Type u_2
o : Type u_3
m' : o → Type ?u.380310
n' : o → Type ?u.380315
R : Type ?u.380318
S : Type ?u.380321
α : Type v
β : Type w
γ : Type ?u.380328
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
i✝ : m
x✝ : o
⊢ (M ⬝ (-N)) i✝ x✝ = (-M ⬝ N) i✝ x✝
Theorem: ENNReal.inv_smul_le_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [inv_inv] using (ENNReal.le_inv_smul_iff (inv_ne_zero hr₀)).symm
state_before: α : Type ?u.304510
β : Type ?u.304513
a✝ b✝ c d : ℝ≥0∞
r✝ p q : ℝ≥0
a b : ℝ≥0∞
r : ℝ≥0
hr₀ : r ≠ 0
⊢ r⁻¹ • a ≤ b ↔ a ≤ r • b
Theorem: Finset.mul_card_image_le_card_of_maps_to
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: simp [mul_comm]
state_before: ι : Type ?u.99968
α : Type u_1
β : Type u_2
M : Type ?u.99977
N : Type ?u.99980
G : Type ?u.99983
k : Type ?u.99986
R : Type ?u.99989
inst✝ : DecidableEq β
f : α → β
s : Finset α
t : Finset β
Hf : ∀ (a : α), a ∈ s → f a ∈ t
n : ℕ
hn : ∀ (a : β), a ∈ t → n ≤ card (filter (fun x => f x = a) s)
⊢ n * card t = ∑ _a in t, n

tactic: rw [← card_eq_sum_card_fiberwise Hf]
state_before: ι : Type ?u.99968
α : Type u_1
β : Type u_2
M : Type ?u.99977
N : Type ?u.99980
G : Type ?u.99983
k : Type ?u.99986
R : Type ?u.99989
inst✝ : DecidableEq β
f : α → β
s : Finset α
t : Finset β
Hf : ∀ (a : α), a ∈ s → f a ∈ t
n : ℕ
hn : ∀ (a : β), a ∈ t → n ≤ card (filter (fun x => f x = a) s)
⊢ ∑ a in t, card (filter (fun x => f x = a) s) = card s
Theorem: Finset.eq_weightedVSubOfPoint_subset_iff_eq_weightedVSubOfPoint_subtype
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [weightedVSubOfPoint_apply]
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.373025
s₂ : Finset ι₂
v : V
x : k
s : Set ι
p : ι → P
b : P
⊢ (∃ fs x_1 w x, v = ↑(weightedVSubOfPoint fs p b) w) ↔ ∃ fs w x, v = ↑(weightedVSubOfPoint fs (fun i => p ↑i) b) w

tactic: constructor
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.373025
s₂ : Finset ι₂
v : V
x : k
s : Set ι
p : ι → P
b : P
⊢ (∃ fs h w h, v = ∑ i in fs, w i • (p i -ᵥ b)) ↔ ∃ fs w h, v = ∑ i in fs, w i • (p ↑i -ᵥ b)

tactic: rintro ⟨fs, hfs, w, rfl, rfl⟩
state_before: case mp
k : Type u_2
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.373025
s₂ : Finset ι₂
v : V
x : k
s : Set ι
p : ι → P
b : P
⊢ (∃ fs h w h, v = ∑ i in fs, w i • (p i -ᵥ b)) → ∃ fs w h, v = ∑ i in fs, w i • (p ↑i -ᵥ b)

tactic: exact ⟨fs.subtype s, fun i => w i, sum_subtype_of_mem _ hfs, (sum_subtype_of_mem _ hfs).symm⟩
state_before: case mp.intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.373025
s₂ : Finset ι₂
s : Set ι
p : ι → P
b : P
fs : Finset ι
hfs : ↑fs ⊆ s
w : ι → k
⊢ ∃ fs_1 w_1 h, ∑ i in fs, w i • (p i -ᵥ b) = ∑ i in fs_1, w_1 i • (p ↑i -ᵥ b)

tactic: rintro ⟨fs, w, rfl, rfl⟩
state_before: case mpr
k : Type u_2
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.373025
s₂ : Finset ι₂
v : V
x : k
s : Set ι
p : ι → P
b : P
⊢ (∃ fs w h, v = ∑ i in fs, w i • (p ↑i -ᵥ b)) → ∃ fs h w h, v = ∑ i in fs, w i • (p i -ᵥ b)

tactic: refine'
    ⟨fs.map (Function.Embedding.subtype _), map_subtype_subset _, fun i =>
      if h : i ∈ s then w ⟨i, h⟩ else 0, _, _⟩ <;>
  simp
state_before: case mpr.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s✝ : Finset ι
ι₂ : Type ?u.373025
s₂ : Finset ι₂
s : Set ι
p : ι → P
b : P
fs : Finset ↑s
w : ↑s → k
⊢ ∃ fs_1 h w_1 h, ∑ i in fs, w i • (p ↑i -ᵥ b) = ∑ i in fs_1, w_1 i • (p i -ᵥ b)
Theorem: Associates.exists_mem_multiset_le_of_prime
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: simpa using h
state_before: α : Type u_1
β : Type ?u.49199
γ : Type ?u.49202
δ : Type ?u.49205
inst✝ : CancelCommMonoidWithZero α
s✝ : Multiset (Associates α)
p : Associates α
hp : Prime p
a : Associates α
s : Multiset (Associates α)
ih : p ≤ Multiset.prod s → ∃ a, a ∈ s ∧ p ≤ a
h : p ≤ Multiset.prod (a ::ₘ s)
⊢ p ≤ a * Multiset.prod s
Theorem: ApplicativeTransformation.coe_inj
File: Mathlib/Control/Traversable/Basic.lean

tactic: cases η
state_before: F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η η' : ApplicativeTransformation F G
h : (fun {α} => app η α) = fun {α} => app η' α
⊢ η = η'

tactic: cases η'
state_before: case mk
F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η' : ApplicativeTransformation F G
app✝ : (α : Type u) → F α → G α
preserves_pure'✝ : ∀ {α : Type u} (x : α), app✝ α (pure x) = pure x
preserves_seq'✝ :
  ∀ {α β : Type u} (x : F (α → β)) (y : F α), app✝ β (Seq.seq x fun x => y) = Seq.seq (app✝ (α → β) x) fun x => app✝ α y
h :
  (fun {α} => app { app := app✝, preserves_pure' := preserves_pure'✝, preserves_seq' := preserves_seq'✝ } α) =
    fun {α} => app η' α
⊢ { app := app✝, preserves_pure' := preserves_pure'✝, preserves_seq' := preserves_seq'✝ } = η'

tactic: congr
state_before: case mk.mk
F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
app✝¹ : (α : Type u) → F α → G α
preserves_pure'✝¹ : ∀ {α : Type u} (x : α), app✝¹ α (pure x) = pure x
preserves_seq'✝¹ :
  ∀ {α β : Type u} (x : F (α → β)) (y : F α),
    app✝¹ β (Seq.seq x fun x => y) = Seq.seq (app✝¹ (α → β) x) fun x => app✝¹ α y
app✝ : (α : Type u) → F α → G α
preserves_pure'✝ : ∀ {α : Type u} (x : α), app✝ α (pure x) = pure x
preserves_seq'✝ :
  ∀ {α β : Type u} (x : F (α → β)) (y : F α), app✝ β (Seq.seq x fun x => y) = Seq.seq (app✝ (α → β) x) fun x => app✝ α y
h :
  (fun {α} => app { app := app✝¹, preserves_pure' := preserves_pure'✝¹, preserves_seq' := preserves_seq'✝¹ } α) =
    fun {α} => app { app := app✝, preserves_pure' := preserves_pure'✝, preserves_seq' := preserves_seq'✝ } α
⊢ { app := app✝¹, preserves_pure' := preserves_pure'✝¹, preserves_seq' := preserves_seq'✝¹ } =
    { app := app✝, preserves_pure' := preserves_pure'✝, preserves_seq' := preserves_seq'✝ }
Theorem: Seminorm.preimage_metric_ball
File: Mathlib/Analysis/Seminorm.lean

tactic: ext x
state_before: R : Type ?u.1006960
R' : Type ?u.1006963
𝕜 : Type u_2
𝕜₂ : Type ?u.1006969
𝕜₃ : Type ?u.1006972
𝕝 : Type ?u.1006975
E : Type u_1
E₂ : Type ?u.1006981
E₃ : Type ?u.1006984
F : Type ?u.1006987
G : Type ?u.1006990
ι : Type ?u.1006993
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
⊢ ↑p ⁻¹' Metric.ball 0 r = {x | ↑p x < r}

tactic: simp only [mem_setOf, mem_preimage, mem_ball_zero_iff, Real.norm_of_nonneg (map_nonneg p _)]
state_before: case h
R : Type ?u.1006960
R' : Type ?u.1006963
𝕜 : Type u_2
𝕜₂ : Type ?u.1006969
𝕜₃ : Type ?u.1006972
𝕝 : Type ?u.1006975
E : Type u_1
E₂ : Type ?u.1006981
E₃ : Type ?u.1006984
F : Type ?u.1006987
G : Type ?u.1006990
ι : Type ?u.1006993
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
x : E
⊢ x ∈ ↑p ⁻¹' Metric.ball 0 r ↔ x ∈ {x | ↑p x < r}
Theorem: IsCompact.mul
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rw [← image_mul_prod]
state_before: ι : Type ?u.168240
α : Type ?u.168243
X : Type ?u.168246
M : Type u_1
N : Type ?u.168252
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact (s * t)

tactic: exact (hs.prod ht).image continuous_mul
state_before: ι : Type ?u.168240
α : Type ?u.168243
X : Type ?u.168246
M : Type u_1
N : Type ?u.168252
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact ((fun x => x.fst * x.snd) '' s ×ˢ t)
Theorem: Real.abs_sin_le_one
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp only [← sq, sin_sq_le_one]
state_before: x y : ℝ
⊢ sin x * sin x ≤ 1
Theorem: Set.prod_eq_biUnion_right
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [iUnion_image_right, image2_mk_eq_prod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.257901
ι : Sort ?u.257904
ι' : Sort ?u.257907
ι₂ : Sort ?u.257910
κ : ι → Sort ?u.257915
κ₁ : ι → Sort ?u.257920
κ₂ : ι → Sort ?u.257925
κ' : ι' → Sort ?u.257930
f : α → β → γ
s : Set α
t : Set β
⊢ s ×ˢ t = ⋃ (b : β) (_ : b ∈ t), (fun a => (a, b)) '' s
Theorem: ContinuedFraction.convergents_eq_convergents'
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

tactic: ext n
state_before: K : Type u_1
n : ℕ
inst✝ : LinearOrderedField K
c : ContinuedFraction K
⊢ convergents ↑↑c = convergents' ↑↑c

tactic: apply convergents_eq_convergents'
state_before: case a
K : Type u_1
n✝ : ℕ
inst✝ : LinearOrderedField K
c : ContinuedFraction K
n : ℕ
⊢ Stream'.nth (convergents ↑↑c) n = Stream'.nth (convergents' ↑↑c) n

tactic: intro gp m _ s_nth_eq
state_before: case a.s_pos
K : Type u_1
n✝ : ℕ
inst✝ : LinearOrderedField K
c : ContinuedFraction K
n : ℕ
⊢ ∀ {gp : Pair K} {m : ℕ}, m < n → Stream'.Seq.get? (↑↑c).s m = some gp → 0 < gp.a ∧ 0 < gp.b

tactic: exact ⟨zero_lt_one.trans_le ((c : SimpleContinuedFraction K).property m gp.a
  (part_num_eq_s_a s_nth_eq)).symm.le, c.property m gp.b <| part_denom_eq_s_b s_nth_eq⟩
state_before: case a.s_pos
K : Type u_1
n✝ : ℕ
inst✝ : LinearOrderedField K
c : ContinuedFraction K
n : ℕ
gp : Pair K
m : ℕ
a✝ : m < n
s_nth_eq : Stream'.Seq.get? (↑↑c).s m = some gp
⊢ 0 < gp.a ∧ 0 < gp.b
Theorem: inv_smul_eq_iff₀
File: Mathlib/GroupTheory/GroupAction/Group.lean

tactic: rw [← h, smul_inv_smul₀ ha]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : GroupWithZero α
inst✝ : MulAction α β
a✝ a : α
ha : a ≠ 0
x y : β
h : a⁻¹ • x = y
⊢ x = a • y

tactic: rw [h, inv_smul_smul₀ ha]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : GroupWithZero α
inst✝ : MulAction α β
a✝ a : α
ha : a ≠ 0
x y : β
h : x = a • y
⊢ a⁻¹ • x = y
Theorem: LieAlgebra.solvable_iff_equiv_solvable
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: constructor <;> intro h
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
e : L' ≃ₗ⁅R⁆ L
⊢ IsSolvable R L' ↔ IsSolvable R L

tactic: exact e.symm.injective.lieAlgebra_isSolvable
state_before: case mp
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
e : L' ≃ₗ⁅R⁆ L
h : IsSolvable R L'
⊢ IsSolvable R L

tactic: exact e.injective.lieAlgebra_isSolvable
state_before: case mpr
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
e : L' ≃ₗ⁅R⁆ L
h : IsSolvable R L
⊢ IsSolvable R L'
Theorem: UniformContinuousOn.continuousOn
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [uniformContinuousOn_iff_restrict] at h
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.150229
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuousOn f s
⊢ ContinuousOn f s

tactic: rw [continuousOn_iff_continuous_restrict]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.150229
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuous (restrict s f)
⊢ ContinuousOn f s

tactic: exact h.continuous
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.150229
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuous (restrict s f)
⊢ Continuous (restrict s f)
Theorem: Equiv.Set.image_symm_apply
File: Mathlib/Logic/Equiv/Set.lean

tactic: apply (Set.image f s H).injective
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set α
H : Injective f
x : α
h : x ∈ s
⊢ ↑(Set.image f s H).symm { val := f x, property := (_ : ∃ a, a ∈ s ∧ f a = f x) } = { val := x, property := h }

tactic: simp [(Set.image f s H).apply_symm_apply]
state_before: case a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set α
H : Injective f
x : α
h : x ∈ s
⊢ ↑(Set.image f s H) (↑(Set.image f s H).symm { val := f x, property := (_ : ∃ a, a ∈ s ∧ f a = f x) }) =
    ↑(Set.image f s H) { val := x, property := h }
Theorem: Stream'.WSeq.get?_mem
File: Mathlib/Data/Seq/WSeq.lean

tactic: revert s
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
n : ℕ
⊢ some a ∈ get? s n → a ∈ s

tactic: induction' n with n IH <;> intro s h
state_before: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, some a ∈ get? s n → a ∈ s

tactic: dsimp only [get?, head] at h
state_before: case zero
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ get? s Nat.zero
⊢ a ∈ s

tactic: rcases Computation.exists_of_mem_map h with ⟨o, h1, h2⟩
state_before: case zero
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s Nat.zero))
⊢ a ∈ s

tactic: cases' o with o
state_before: case zero.intro.intro
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s Nat.zero))
o : Option (α × WSeq α)
h1 : o ∈ destruct (drop s Nat.zero)
h2 : Prod.fst <$> o = some a
⊢ a ∈ s

tactic: injection h2 with h'
state_before: case zero.intro.intro.some
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s Nat.zero))
o : α × WSeq α
h1 : some o ∈ destruct (drop s Nat.zero)
h2 : Prod.fst <$> some o = some a
⊢ a ∈ s

tactic: cases' o with a' s'
state_before: case zero.intro.intro.some
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s Nat.zero))
o : α × WSeq α
h1 : some o ∈ destruct (drop s Nat.zero)
h' : o.fst = a
⊢ a ∈ s

tactic: exact (eq_or_mem_iff_mem h1).2 (Or.inl h'.symm)
state_before: case zero.intro.intro.some.mk
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s Nat.zero))
a' : α
s' : WSeq α
h1 : some (a', s') ∈ destruct (drop s Nat.zero)
h' : (a', s').fst = a
⊢ a ∈ s

tactic: injection h2
state_before: case zero.intro.intro.none
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s Nat.zero))
h1 : none ∈ destruct (drop s Nat.zero)
h2 : Prod.fst <$> none = some a
⊢ a ∈ s

tactic: have := @IH (tail s)
state_before: case succ
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, some a ∈ get? s n → a ∈ s
s : WSeq α
h : some a ∈ get? s (Nat.succ n)
⊢ a ∈ s

tactic: rw [get?_tail] at this
state_before: case succ
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, some a ∈ get? s n → a ∈ s
s : WSeq α
h : some a ∈ get? s (Nat.succ n)
this : some a ∈ get? (tail s) n → a ∈ tail s
⊢ a ∈ s

tactic: exact mem_of_mem_tail (this h)
state_before: case succ
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, some a ∈ get? s n → a ∈ s
s : WSeq α
h : some a ∈ get? s (Nat.succ n)
this : some a ∈ get? s (n + 1) → a ∈ tail s
⊢ a ∈ s
Theorem: LinearOrderedAddCommGroup.tendsto_nhds
File: Mathlib/Topology/Order/Basic.lean

tactic: simp [nhds_eq_iInf_abs_sub, abs_sub_comm a]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
x : Filter β
a : α
⊢ Tendsto f x (𝓝 a) ↔ ∀ (ε : α), ε > 0 → ∀ᶠ (b : β) in x, abs (f b - a) < ε
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIdIso_hom_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIdIso
state_before: C : Type u_2
inst✝⁵ : Category C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ :
  HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i))
⊢ (pullbackDiagonalMapIdIso f g i).hom ≫ snd = snd ≫ snd

tactic: simp
state_before: C : Type u_2
inst✝⁵ : Category C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ :
  HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i))
⊢ (asIso
            (map (diagonal i)
              (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i)) (diagonal i)
              (map ((f ≫ inv fst) ≫ snd) ((g ≫ inv fst) ≫ snd) i i ((f ≫ inv fst) ≫ fst) ((g ≫ inv fst) ≫ fst) (𝟙 S)
                (_ : ((f ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((f ≫ inv fst) ≫ fst) ≫ i)
                (_ : ((g ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((g ≫ inv fst) ≫ fst) ≫ i))
              (𝟙 T) (congrHom (_ : f ≫ i = (f ≫ inv fst) ≫ snd) (_ : g ≫ i = (g ≫ inv fst) ≫ snd)).hom
              (𝟙 (diagonalObj i)) (_ : diagonal i ≫ 𝟙 (diagonalObj i) = 𝟙 T ≫ diagonal i)
              (_ :
                map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i) ≫
                    𝟙 (diagonalObj i) =
                  (congrHom (_ : f ≫ i = (f ≫ inv fst) ≫ snd) (_ : g ≫ i = (g ≫ inv fst) ≫ snd)).hom ≫
                    map ((f ≫ inv fst) ≫ snd) ((g ≫ inv fst) ≫ snd) i i ((f ≫ inv fst) ≫ fst) ((g ≫ inv fst) ≫ fst)
                      (𝟙 S) (_ : ((f ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((f ≫ inv fst) ≫ fst) ≫ i)
                      (_ : ((g ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((g ≫ inv fst) ≫ fst) ≫ i))) ≪≫
          pullbackDiagonalMapIso i (𝟙 S) (f ≫ inv fst) (g ≫ inv fst) ≪≫
            asIso
              (map (f ≫ inv fst) (g ≫ inv fst) f g (𝟙 X) (𝟙 Y) fst (_ : (f ≫ inv fst) ≫ fst = 𝟙 X ≫ f)
                (_ : (g ≫ inv fst) ≫ fst = 𝟙 Y ≫ g))).hom ≫
      snd =
    snd ≫ snd