tasksource/leandojo huggingface dataset:
Theorem: Matrix.isHermitian_mul_mul_conjTranspose
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: simp only [IsHermitian, conjTranspose_mul, conjTranspose_conjTranspose, hA.eq, Matrix.mul_assoc]
state_before: α : Type u_2
β : Type ?u.39086
m : Type u_1
n : Type u_3
A✝ : Matrix n n α
inst✝⁴ : NonUnitalSemiring α
inst✝³ : StarRing α
inst✝² : NonUnitalSemiring β
inst✝¹ : StarRing β
inst✝ : Fintype m
A : Matrix m m α
B : Matrix n m α
hA : IsHermitian A
⊢ IsHermitian (B ⬝ A ⬝ Bᴴ)
Theorem: MvPolynomial.vars_add_of_disjoint
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: apply Finset.Subset.antisymm (vars_add_subset p q)
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.158991
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
h : Disjoint (vars p) (vars q)
⊢ vars (p + q) = vars p ∪ vars q

tactic: intro x hx
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.158991
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
h : Disjoint (vars p) (vars q)
⊢ vars p ∪ vars q ⊆ vars (p + q)

tactic: simp only [vars_def, Multiset.disjoint_toFinset] at h hx⊢
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.158991
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
h : Disjoint (vars p) (vars q)
x : σ
hx : x ∈ vars p ∪ vars q
⊢ x ∈ vars (p + q)

tactic: rw [degrees_add_of_disjoint h, Multiset.toFinset_union]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.158991
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
x : σ
h : Multiset.Disjoint (degrees p) (degrees q)
hx : x ∈ Multiset.toFinset (degrees p) ∪ Multiset.toFinset (degrees q)
⊢ x ∈ Multiset.toFinset (degrees (p + q))

tactic: exact hx
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.158991
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
x : σ
h : Multiset.Disjoint (degrees p) (degrees q)
hx : x ∈ Multiset.toFinset (degrees p) ∪ Multiset.toFinset (degrees q)
⊢ x ∈ Multiset.toFinset (degrees p) ∪ Multiset.toFinset (degrees q)
Theorem: List.filterTR_loop_eq
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as generalizing bs with
| nil => simp [filterTR.loop, filter]
| cons a as ih =>
  simp [filterTR.loop, filter]
  split
  next => rw [ih, reverse_cons, append_assoc]; simp
  next => rw [ih]
state_before: α : Type u
β : Type v
γ : Type w
p : α → Bool
as bs : List α
⊢ filterTR.loop p as bs = reverse bs ++ filter p as

tactic: simp [filterTR.loop, filter]
state_before: case nil
α : Type u
β : Type v
γ : Type w
p : α → Bool
bs : List α
⊢ filterTR.loop p nil bs = reverse bs ++ filter p nil

tactic: simp [filterTR.loop, filter]
state_before: case cons
α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
⊢ filterTR.loop p (a :: as) bs = reverse bs ++ filter p (a :: as)

tactic: split
state_before: case cons
α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
⊢ (match p a with
    | true => filterTR.loop p as (a :: bs)
    | false => filterTR.loop p as bs) =
    reverse bs ++
      match p a with
      | true => a :: filter p as
      | false => filter p as

tactic: next => rw [ih, reverse_cons, append_assoc]; simp
state_before: case cons.h_1
α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
x✝ : Bool
heq✝ : p a = true
⊢ filterTR.loop p as (a :: bs) = reverse bs ++ a :: filter p as

case cons.h_2
α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
x✝ : Bool
heq✝ : p a = false
⊢ filterTR.loop p as bs = reverse bs ++ filter p as

tactic: next => rw [ih]
state_before: case cons.h_2
α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
x✝ : Bool
heq✝ : p a = false
⊢ filterTR.loop p as bs = reverse bs ++ filter p as

tactic: rw [ih, reverse_cons, append_assoc]
state_before: α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
x✝ : Bool
heq✝ : p a = true
⊢ filterTR.loop p as (a :: bs) = reverse bs ++ a :: filter p as

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
x✝ : Bool
heq✝ : p a = true
⊢ reverse bs ++ (a :: nil ++ filter p as) = reverse bs ++ a :: filter p as

tactic: rw [ih]
state_before: α : Type u
β : Type v
γ : Type w
p : α → Bool
a : α
as : List α
ih : ∀ (bs : List α), filterTR.loop p as bs = reverse bs ++ filter p as
bs : List α
x✝ : Bool
heq✝ : p a = false
⊢ filterTR.loop p as bs = reverse bs ++ filter p as
Theorem: List.pmap_eq_nil
File: Mathlib/Data/List/Basic.lean

tactic: rw [← length_eq_zero, length_pmap, length_eq_zero]
state_before: ι : Type ?u.330793
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
⊢ pmap f l H = [] ↔ l = []
Theorem: Equiv.Perm.sameCycle_apply_right
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [sameCycle_comm, sameCycle_apply_left, sameCycle_comm]
state_before: ι : Type ?u.77113
α : Type u_1
β : Type ?u.77119
f g : Perm α
p : α → Prop
x y z : α
⊢ SameCycle f x (↑f y) ↔ SameCycle f x y
Theorem: Part.some_union_some
File: Mathlib/Data/Part.lean

tactic: simp [union_def]
state_before: α : Type u_1
β : Type ?u.95055
γ : Type ?u.95058
inst✝ : Union α
a b : α
⊢ some a ∪ some b = some (a ∪ b)
Theorem: CharTwo.two_eq_zero
File: Mathlib/Algebra/CharP/Two.lean

tactic: rw [← Nat.cast_two, CharP.cast_eq_zero]
state_before: R : Type u_1
ι : Type ?u.157
inst✝¹ : Semiring R
inst✝ : CharP R 2
⊢ 2 = 0
Theorem: hasFDerivWithinAt_univ
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simp only [HasFDerivWithinAt, nhdsWithin_univ]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.174866
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.174961
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
⊢ HasFDerivWithinAt f f' univ x ↔ HasFDerivAt f f' x

tactic: rfl
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.174866
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.174961
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
⊢ HasFDerivAtFilter f f' x (𝓝 x) ↔ HasFDerivAt f f' x
Theorem: irreducible_or_factor
File: Mathlib/Algebra/Associated.lean

tactic: haveI := Classical.dec
state_before: α✝ : Type ?u.79346
β : Type ?u.79349
γ : Type ?u.79352
δ : Type ?u.79355
α : Type u_1
inst✝ : Monoid α
x : α
h : ¬IsUnit x
⊢ Irreducible x ∨ ∃ a b, ¬IsUnit a ∧ ¬IsUnit b ∧ a * b = x

tactic: refine' or_iff_not_imp_right.2 fun H => _
state_before: α✝ : Type ?u.79346
β : Type ?u.79349
γ : Type ?u.79352
δ : Type ?u.79355
α : Type u_1
inst✝ : Monoid α
x : α
h : ¬IsUnit x
this : (p : Prop) → Decidable p
⊢ Irreducible x ∨ ∃ a b, ¬IsUnit a ∧ ¬IsUnit b ∧ a * b = x

tactic: simp [h, irreducible_iff] at H⊢
state_before: α✝ : Type ?u.79346
β : Type ?u.79349
γ : Type ?u.79352
δ : Type ?u.79355
α : Type u_1
inst✝ : Monoid α
x : α
h : ¬IsUnit x
this : (p : Prop) → Decidable p
H : ¬∃ a b, ¬IsUnit a ∧ ¬IsUnit b ∧ a * b = x
⊢ Irreducible x

tactic: refine' fun a b h => by_contradiction fun o => _
state_before: α✝ : Type ?u.79346
β : Type ?u.79349
γ : Type ?u.79352
δ : Type ?u.79355
α : Type u_1
inst✝ : Monoid α
x : α
h : ¬IsUnit x
this : (p : Prop) → Decidable p
H : ∀ (x_1 : α), ¬IsUnit x_1 → ∀ (x_2 : α), ¬IsUnit x_2 → ¬x_1 * x_2 = x
⊢ ∀ (a b : α), x = a * b → IsUnit a ∨ IsUnit b

tactic: simp [not_or] at o
state_before: α✝ : Type ?u.79346
β : Type ?u.79349
γ : Type ?u.79352
δ : Type ?u.79355
α : Type u_1
inst✝ : Monoid α
x : α
h✝ : ¬IsUnit x
this : (p : Prop) → Decidable p
H : ∀ (x_1 : α), ¬IsUnit x_1 → ∀ (x_2 : α), ¬IsUnit x_2 → ¬x_1 * x_2 = x
a b : α
h : x = a * b
o : ¬(IsUnit a ∨ IsUnit b)
⊢ False

tactic: exact H _ o.1 _ o.2 h.symm
state_before: α✝ : Type ?u.79346
β : Type ?u.79349
γ : Type ?u.79352
δ : Type ?u.79355
α : Type u_1
inst✝ : Monoid α
x : α
h✝ : ¬IsUnit x
this : (p : Prop) → Decidable p
H : ∀ (x_1 : α), ¬IsUnit x_1 → ∀ (x_2 : α), ¬IsUnit x_2 → ¬x_1 * x_2 = x
a b : α
h : x = a * b
o : ¬IsUnit a ∧ ¬IsUnit b
⊢ False
Theorem: MvQPF.supp_eq
File: Mathlib/Data/QPF/Multivariate/Basic.lean

tactic: ext
state_before: n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
i : Fin2 n
x : F α
⊢ supp x i = {u | ∀ (a : (P F).A) (f : MvPFunctor.B (P F) a ⟹ α), abs { fst := a, snd := f } = x → u ∈ f i '' univ}

tactic: apply mem_supp
state_before: case h
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
i : Fin2 n
x : F α
x✝ : α i
⊢ x✝ ∈ supp x i ↔
    x✝ ∈ {u | ∀ (a : (P F).A) (f : MvPFunctor.B (P F) a ⟹ α), abs { fst := a, snd := f } = x → u ∈ f i '' univ}
Theorem: Subalgebra.fg_top
File: Mathlib/RingTheory/Adjoin/FG.lean

tactic: rw [← S.range_val, ← Algebra.map_top]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : FG ⊤
⊢ FG S

tactic: exact FG.map _ h
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : FG ⊤
⊢ FG (map (val S) ⊤)

tactic: rw [Algebra.map_top, range_val]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : FG S
⊢ FG (map (val S) ⊤)

tactic: exact h
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : FG S
⊢ FG S
Theorem: Nat.two_dvd_centralBinom_succ
File: Mathlib/Data/Nat/Choose/Central.lean

tactic: use (n + 1 + n).choose n
state_before: n : ℕ
⊢ 2 ∣ centralBinom (n + 1)

tactic: rw [centralBinom_eq_two_mul_choose, two_mul, ← add_assoc,
    choose_succ_succ' (n + 1 + n) n, choose_symm_add, ← two_mul]
state_before: n : ℕ
⊢ centralBinom (n + 1) = 2 * choose (n + 1 + n) n
Theorem: CategoryTheory.Presieve.FamilyOfElements.Compatible.pullback
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: simp only [compatible_iff_sieveCompatible] at h ⊢
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
f : Y ⟶ X
x : FamilyOfElements P S.arrows
h : Compatible x
⊢ Compatible (FamilyOfElements.pullback f x)

tactic: intro W Z f₁ f₂ hf
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
f : Y ⟶ X
x : FamilyOfElements P S.arrows
h : SieveCompatible x
⊢ SieveCompatible (FamilyOfElements.pullback f x)

tactic: unfold FamilyOfElements.pullback
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
f : Y ⟶ X
x : FamilyOfElements P S.arrows
h : SieveCompatible x
W Z : C
f₁ : W ⟶ Y
f₂ : Z ⟶ W
hf : (Sieve.pullback f S).arrows f₁
⊢ FamilyOfElements.pullback f x (f₂ ≫ f₁) (_ : (Sieve.pullback f S).arrows (f₂ ≫ f₁)) =
    P.map f₂.op (FamilyOfElements.pullback f x f₁ hf)

tactic: rw [← h (f₁ ≫ f) f₂ hf]
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
f : Y ⟶ X
x : FamilyOfElements P S.arrows
h : SieveCompatible x
W Z : C
f₁ : W ⟶ Y
f₂ : Z ⟶ W
hf : (Sieve.pullback f S).arrows f₁
⊢ x ((f₂ ≫ f₁) ≫ f) (_ : (Sieve.pullback f S).arrows (f₂ ≫ f₁)) = P.map f₂.op (x (f₁ ≫ f) hf)

tactic: congr 1
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
f : Y ⟶ X
x : FamilyOfElements P S.arrows
h : SieveCompatible x
W Z : C
f₁ : W ⟶ Y
f₂ : Z ⟶ W
hf : (Sieve.pullback f S).arrows f₁
⊢ x ((f₂ ≫ f₁) ≫ f) (_ : (Sieve.pullback f S).arrows (f₂ ≫ f₁)) = x (f₂ ≫ f₁ ≫ f) (_ : S.arrows (f₂ ≫ f₁ ≫ f))

tactic: simp only [assoc]
state_before: case e_f
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
f : Y ⟶ X
x : FamilyOfElements P S.arrows
h : SieveCompatible x
W Z : C
f₁ : W ⟶ Y
f₂ : Z ⟶ W
hf : (Sieve.pullback f S).arrows f₁
⊢ (f₂ ≫ f₁) ≫ f = f₂ ≫ f₁ ≫ f
Theorem: Set.op_smul_inter_ne_empty_iff
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: rw [← nonempty_iff_ne_empty]
state_before: F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x

tactic: constructor
state_before: F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ Set.Nonempty (x • s ∩ t) ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x

tactic: rintro ⟨a, h, ha⟩
state_before: case mp
F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ Set.Nonempty (x • s ∩ t) → ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x

tactic: obtain ⟨b, hb, rfl⟩ := mem_smul_set.mp h
state_before: case mp.intro.intro
F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a✝ : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
a : α
h : a ∈ x • s
ha : a ∈ t
⊢ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x

tactic: exact ⟨b, x • b, ⟨hb, ha⟩, by simp⟩
state_before: case mp.intro.intro.intro.intro
F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
b : α
hb : b ∈ s
h : x • b ∈ x • s
ha : x • b ∈ t
⊢ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x

tactic: simp
state_before: F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
b : α
hb : b ∈ s
h : x • b ∈ x • s
ha : x • b ∈ t
⊢ b⁻¹ * x • b = unop x

tactic: rintro ⟨a, b, ⟨ha, hb⟩, H⟩
state_before: case mpr
F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ (∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x) → Set.Nonempty (x • s ∩ t)

tactic: have : MulOpposite.op (a⁻¹ * b) = x := congr_arg MulOpposite.op H
state_before: case mpr.intro.intro.intro.intro
F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a✝ : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
a b : α
H : a⁻¹ * b = unop x
ha : a ∈ s
hb : b ∈ t
⊢ Set.Nonempty (x • s ∩ t)

tactic: exact ⟨b, mem_inter (mem_smul_set.mpr ⟨a, ha, by simp [← this]⟩) hb⟩
state_before: case mpr.intro.intro.intro.intro
F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a✝ : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
a b : α
H : a⁻¹ * b = unop x
ha : a ∈ s
hb : b ∈ t
this : op (a⁻¹ * b) = x
⊢ Set.Nonempty (x • s ∩ t)

tactic: simp [← this]
state_before: F : Type ?u.145512
α : Type u_1
β : Type ?u.145518
γ : Type ?u.145521
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a✝ : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
a b : α
H : a⁻¹ * b = unop x
ha : a ∈ s
hb : b ∈ t
this : op (a⁻¹ * b) = x
⊢ x • a = b
Theorem: Finset.max'_insert
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [coe_insert, max_comm]
state_before: F : Type ?u.359873
α : Type u_1
β : Type ?u.359879
γ : Type ?u.359882
ι : Type ?u.359885
κ : Type ?u.359888
inst✝ : LinearOrder α
s✝ : Finset α
H✝ : Finset.Nonempty s✝
x a : α
s : Finset α
H : Finset.Nonempty s
⊢ IsGreatest (↑(insert a s)) (max (max' s H) a)

tactic: exact (isGreatest_max' _ _).insert _
state_before: F : Type ?u.359873
α : Type u_1
β : Type ?u.359879
γ : Type ?u.359882
ι : Type ?u.359885
κ : Type ?u.359888
inst✝ : LinearOrder α
s✝ : Finset α
H✝ : Finset.Nonempty s✝
x a : α
s : Finset α
H : Finset.Nonempty s
⊢ IsGreatest (insert a ↑s) (max a (max' s H))
Theorem: MeasureTheory.quasiMeasurePreserving_div_left_of_right_invariant
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: rw [← μ.inv_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g / h

tactic: exact
  (quasiMeasurePreserving_div_left μ.inv g).mono (inv_absolutelyContinuous μ.inv)
    (absolutelyContinuous_inv μ.inv)
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g / h
Theorem: Finset.isUnit_iff_singleton_aux
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp only [Group.isUnit, and_true_iff]
state_before: F : Type ?u.614796
α : Type u_1
β : Type ?u.614802
γ : Type ?u.614805
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ (∃ a, s = {a} ∧ IsUnit a) ↔ ∃ a, s = {a}
Theorem: Multiset.prod_nsmul
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [zero_nsmul, pow_zero]
state_before: ι : Type ?u.14945
α : Type u_1
β : Type ?u.14951
γ : Type ?u.14954
inst✝ : CommMonoid α
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ prod (0 • m) = prod m ^ 0

tactic: rfl
state_before: ι : Type ?u.14945
α : Type u_1
β : Type ?u.14951
γ : Type ?u.14954
inst✝ : CommMonoid α
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ prod 0 = 1

tactic: rw [add_nsmul, one_nsmul, pow_add, pow_one, prod_add, prod_nsmul m n]
state_before: ι : Type ?u.14945
α : Type u_1
β : Type ?u.14951
γ : Type ?u.14954
inst✝ : CommMonoid α
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
n : ℕ
⊢ prod ((n + 1) • m) = prod m ^ (n + 1)
Theorem: CategoryTheory.Limits.Multicofork.snd_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [← K.w (WalkingMultispan.Hom.snd a)]
state_before: C : Type u
inst✝ : Category C
I : MultispanIndex C
K : Multicofork I
a : I.L
⊢ K.ι.app (WalkingMultispan.left a) = MultispanIndex.snd I a ≫ π K (MultispanIndex.sndFrom I a)

tactic: rfl
state_before: C : Type u
inst✝ : Category C
I : MultispanIndex C
K : Multicofork I
a : I.L
⊢ (MultispanIndex.multispan I).map (WalkingMultispan.Hom.snd a) ≫
      K.ι.app (WalkingMultispan.right (MultispanIndex.sndFrom I a)) =
    MultispanIndex.snd I a ≫ π K (MultispanIndex.sndFrom I a)
Theorem: map_mul_left_nhds_one₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: rw [map_mul_left_nhds₀ ha, mul_one]
state_before: α : Type ?u.52656
β : Type ?u.52659
G₀ : Type u_1
inst✝² : TopologicalSpace G₀
inst✝¹ : GroupWithZero G₀
inst✝ : ContinuousMul G₀
a : G₀
ha : a ≠ 0
⊢ map (fun x => a * x) (𝓝 1) = 𝓝 a
Theorem: List.cons_get_drop_succ
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl hl
state_before: ι : Type ?u.200056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : Fin (length l)
⊢ get l n :: drop (↑n + 1) l = drop (↑n) l

tactic: exact absurd n.1.zero_le (not_le_of_lt (nomatch n))
state_before: case nil
ι : Type ?u.200056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n✝ : Fin (length l)
n : Fin (length [])
⊢ get [] n :: drop (↑n + 1) [] = drop ↑n []

tactic: match n with
| ⟨0, _⟩ => simp [get]
| ⟨n+1, hn⟩ =>
  simp only [Nat.succ_lt_succ_iff, List.length] at hn
  simpa [List.get, List.drop] using hl
state_before: case cons
ι : Type ?u.200056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n✝ : Fin (length l)
hd : α
tl : List α
hl : ∀ {n : Fin (length tl)}, get tl n :: drop (↑n + 1) tl = drop (↑n) tl
n : Fin (length (hd :: tl))
⊢ get (hd :: tl) n :: drop (↑n + 1) (hd :: tl) = drop (↑n) (hd :: tl)

tactic: simp [get]
state_before: ι : Type ?u.200056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n✝ : Fin (length l)
hd : α
tl : List α
hl : ∀ {n : Fin (length tl)}, get tl n :: drop (↑n + 1) tl = drop (↑n) tl
n : Fin (length (hd :: tl))
isLt✝ : 0 < length (hd :: tl)
⊢ get (hd :: tl) { val := 0, isLt := isLt✝ } :: drop (↑{ val := 0, isLt := isLt✝ } + 1) (hd :: tl) =
    drop (↑{ val := 0, isLt := isLt✝ }) (hd :: tl)

tactic: simp only [Nat.succ_lt_succ_iff, List.length] at hn
state_before: ι : Type ?u.200056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n✝¹ : Fin (length l)
hd : α
tl : List α
hl : ∀ {n : Fin (length tl)}, get tl n :: drop (↑n + 1) tl = drop (↑n) tl
n✝ : Fin (length (hd :: tl))
n : ℕ
hn : n + 1 < length (hd :: tl)
⊢ get (hd :: tl) { val := n + 1, isLt := hn } :: drop (↑{ val := n + 1, isLt := hn } + 1) (hd :: tl) =
    drop (↑{ val := n + 1, isLt := hn }) (hd :: tl)

tactic: simpa [List.get, List.drop] using hl
state_before: ι : Type ?u.200056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n✝¹ : Fin (length l)
hd : α
tl : List α
hl : ∀ {n : Fin (length tl)}, get tl n :: drop (↑n + 1) tl = drop (↑n) tl
n✝ : Fin (length (hd :: tl))
n : ℕ
hn✝ : n + 1 < length (hd :: tl)
hn : n < length tl
⊢ get (hd :: tl) { val := n + 1, isLt := hn✝ } :: drop (↑{ val := n + 1, isLt := hn✝ } + 1) (hd :: tl) =
    drop (↑{ val := n + 1, isLt := hn✝ }) (hd :: tl)
Theorem: AlgEquiv.restrictNormal_trans
File: Mathlib/FieldTheory/Normal.lean

tactic: simp only [AlgEquiv.trans_apply, AlgEquiv.restrictNormal_commutes]
state_before: F : Type u_1
K : Type ?u.382075
inst✝¹⁸ : Field F
inst✝¹⁷ : Field K
inst✝¹⁶ : Algebra F K
K₁ : Type u_3
K₂ : Type u_5
K₃ : Type u_4
inst✝¹⁵ : Field F
inst✝¹⁴ : Field K₁
inst✝¹³ : Field K₂
inst✝¹² : Field K₃
inst✝¹¹ : Algebra F K₁
inst✝¹⁰ : Algebra F K₂
inst✝⁹ : Algebra F K₃
ϕ : K₁ →ₐ[F] K₂
χ : K₁ ≃ₐ[F] K₂
ψ : K₂ →ₐ[F] K₃
ω : K₂ ≃ₐ[F] K₃
E : Type u_2
inst✝⁸ : Field E
inst✝⁷ : Algebra F E
inst✝⁶ : Algebra E K₁
inst✝⁵ : Algebra E K₂
inst✝⁴ : Algebra E K₃
inst✝³ : IsScalarTower F E K₁
inst✝² : IsScalarTower F E K₂
inst✝¹ : IsScalarTower F E K₃
inst✝ : Normal F E
x✝ : E
⊢ ↑(algebraMap E K₃) (↑(restrictNormal (trans χ ω) E) x✝) =
    ↑(algebraMap E K₃) (↑(trans (restrictNormal χ E) (restrictNormal ω E)) x✝)
Theorem: dist_self_homothety
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [dist_comm, dist_homothety_self]
state_before: α : Type ?u.52305
V : Type u_2
P : Type u_1
W : Type ?u.52314
Q : Type ?u.52317
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist p₂ (↑(homothety p₁ c) p₂) = ‖1 - c‖ * dist p₁ p₂