1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CliffordAlgebra.lift_comp_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean

tactic: exact (lift Q : _ ≃ (CliffordAlgebra Q →ₐ[R] A)).apply_symm_apply g
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
g : CliffordAlgebra Q →ₐ[R] A
⊢ (lift Q) ⟨g.toLinearMap ∘ₗ ι Q, ⋯⟩ = g
state_after: no goals
Theorem: DirichletCharacter.Odd.toUnitHom_eval_neg_one
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

tactic: rw [← Units.eq_iff, MulChar.coe_toUnitHom]
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
hψ : ψ.Odd
⊢ (toUnitHom ψ) (-1) = -1
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
hψ : ψ.Odd
⊢ ψ ↑(-1) = ↑(-1)

tactic: exact hψ
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
hψ : ψ.Odd
⊢ ψ ↑(-1) = ↑(-1)
state_after: no goals
Theorem: Matrix.J_squared
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: rw [J, fromBlocks_multiply]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ J l R * J l R = -1
state_after: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (0 * 0 + -1 * 1) (0 * -1 + -1 * 0) (1 * 0 + 0 * 1) (1 * -1 + 0 * 0) = -1

tactic: simp only [Matrix.zero_mul, Matrix.neg_mul, zero_add, neg_zero, Matrix.one_mul, add_zero]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (0 * 0 + -1 * 1) (0 * -1 + -1 * 0) (1 * 0 + 0 * 1) (1 * -1 + 0 * 0) = -1
state_after: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (-1) 0 0 (-1) = -1

tactic: rw [← neg_zero, ← Matrix.fromBlocks_neg, ← fromBlocks_one]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (-1) 0 0 (-1) = -1
state_after: no goals
Theorem: Multiset.coe_eq_singleton
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← coe_singleton, coe_eq_coe, List.perm_singleton]
state_before: α : Type u_1
β : Type v
γ : Type u_2
l : List α
a : α
⊢ ↑l = {a} ↔ l = [a]
state_after: no goals
Theorem: summable_powerSeries_of_norm_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝¹ : NormedDivisionRing α
inst✝ : CompleteSpace α
f : ℕ → α
z : α
h : CauchySeq fun n => ∑ i ∈ Finset.range n, f i
hz : ‖z‖ < 1
⊢ CauchySeq fun n => ∑ i ∈ Finset.range n, f i * 1 ^ i
state_after: no goals

tactic: simp [hz]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝¹ : NormedDivisionRing α
inst✝ : CompleteSpace α
f : ℕ → α
z : α
h : CauchySeq fun n => ∑ i ∈ Finset.range n, f i
hz : ‖z‖ < 1
⊢ ‖z‖ < ‖1‖
state_after: no goals
Theorem: ENNReal.coe_rpow_of_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← ENNReal.some_eq_coe]
state_before: x : ℝ≥0
h : x ≠ 0
y : ℝ
⊢ ↑x ^ y = ↑(x ^ y)
state_after: x : ℝ≥0
h : x ≠ 0
y : ℝ
⊢ some x ^ y = ↑(x ^ y)

tactic: simp [h]
state_before: x : ℝ≥0
h : x ≠ 0
y : ℝ
⊢ (if x = 0 ∧ y < 0 then ⊤ else ↑(x.rpow y)) = ↑(x.rpow y)
state_after: no goals
Theorem: Nat.gcd_mul_gcd_of_coprime_of_mul_eq_mul
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

tactic: apply Nat.dvd_antisymm
state_before: c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ a.gcd c * b.gcd c = c
state_after: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ a.gcd c * b.gcd c ∣ c

case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ a.gcd c * b.gcd c

tactic: apply ((cop.gcd_left _).mul (cop.gcd_left _)).dvd_of_dvd_mul_right
state_before: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ a.gcd c * b.gcd c ∣ c
state_after: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ a.gcd c * b.gcd c ∣ c * d

tactic: rw [← h]
state_before: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ a.gcd c * b.gcd c ∣ c * d
state_after: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ a.gcd c * b.gcd c ∣ a * b

tactic: apply Nat.mul_dvd_mul (gcd_dvd ..).1 (gcd_dvd ..).1
state_before: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ a.gcd c * b.gcd c ∣ a * b
state_after: no goals

tactic: rw [gcd_comm a, gcd_comm b]
state_before: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ a.gcd c * b.gcd c
state_after: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ c.gcd a * c.gcd b

tactic: refine Nat.dvd_trans ?_ (gcd_mul_dvd_mul_gcd ..)
state_before: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ c.gcd a * c.gcd b
state_after: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ c.gcd (a * b)

tactic: rw [h, gcd_mul_right_right d c]
state_before: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ c.gcd (a * b)
state_after: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ c

tactic: apply Nat.dvd_refl
state_before: case a
c d a b : Nat
cop : c.Coprime d
h : a * b = c * d
⊢ c ∣ c
state_after: no goals
Theorem: CauSeq.Completion.mk_eq_zero
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

tactic: have : mk f = 0 ↔ LimZero (f - 0) := Quotient.eq
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
⊢ mk f = 0 ↔ f.LimZero
state_after: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
this : mk f = 0 ↔ (f - 0).LimZero
⊢ mk f = 0 ↔ f.LimZero

tactic: rwa [sub_zero] at this
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
this : mk f = 0 ↔ (f - 0).LimZero
⊢ mk f = 0 ↔ f.LimZero
state_after: no goals
Theorem: List.mergeSort_singleton
File: Mathlib/Data/List/Sort.lean

tactic: rw [List.mergeSort]
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
⊢ mergeSort r [a] = [a]
state_after: no goals
Theorem: Finset.mem_shadow_iterate_iff_exists_card
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: induction' k with k ih generalizing t
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
state_after: case zero
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r : ℕ
t : Finset α
⊢ t ∈ ∂ ^[0] 𝒜 ↔ ∃ u, u.card = 0 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜

case succ
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r k : ℕ
ih : ∀ {t : Finset α}, t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
t : Finset α
⊢ t ∈ ∂ ^[k + 1] 𝒜 ↔ ∃ u, u.card = k + 1 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜

tactic: set_option tactic.skipAssignedInstances false in
simp only [mem_shadow_iff_insert_mem, ih, Function.iterate_succ_apply', card_eq_succ]
aesop
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r k : ℕ
ih : ∀ {t : Finset α}, t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
t : Finset α
⊢ t ∈ ∂ ^[k + 1] 𝒜 ↔ ∃ u, u.card = k + 1 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
state_after: no goals

tactic: simp
state_before: case zero
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r : ℕ
t : Finset α
⊢ t ∈ ∂ ^[0] 𝒜 ↔ ∃ u, u.card = 0 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
state_after: no goals

tactic: simp only [mem_shadow_iff_insert_mem, ih, Function.iterate_succ_apply', card_eq_succ]
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r k : ℕ
ih : ∀ {t : Finset α}, t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
t : Finset α
⊢ t ∈ ∂ ^[k + 1] 𝒜 ↔ ∃ u, u.card = k + 1 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
state_after: case succ
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r k : ℕ
ih : ∀ {t : Finset α}, t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
t : Finset α
⊢ (∃ a ∉ t, ∃ u, u.card = k ∧ Disjoint (insert a t) u ∧ insert a t ∪ u ∈ 𝒜) ↔
    ∃ u, (∃ a t, a ∉ t ∧ insert a t = u ∧ t.card = k) ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜

tactic: aesop
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r k : ℕ
ih : ∀ {t : Finset α}, t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
t : Finset α
⊢ (∃ a ∉ t, ∃ u, u.card = k ∧ Disjoint (insert a t) u ∧ insert a t ∪ u ∈ 𝒜) ↔
    ∃ u, (∃ a t, a ∉ t ∧ insert a t = u ∧ t.card = k) ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
state_after: no goals
Theorem: Substring.Valid.data_dropWhile
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [(h.dropWhile _).toString, h.toString]
state_before: p : Char → Bool
x✝ : Substring
h✝ : x✝.Valid
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ (x✝.dropWhile p).toString.data = List.dropWhile p x✝.toString.data
state_after: no goals
Theorem: Filter.IsBasis.mem_filter_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [IsBasis.filter, FilterBasis.mem_filter_iff, mem_filterBasis_iff,
  exists_exists_and_eq_and]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
p : ι → Prop
s : ι → Set α
h : IsBasis p s
U : Set α
⊢ U ∈ h.filter ↔ ∃ i, p i ∧ s i ⊆ U
state_after: no goals
Theorem: MeasureTheory.Integrable.ae_eq_of_withDensityᵥ_eq
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: refine hf.ae_eq_of_forall_setIntegral_eq f g hg fun i hi _ => ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : μ.withDensityᵥ f = μ.withDensityᵥ g
⊢ f =ᶠ[ae μ] g
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : μ.withDensityᵥ f = μ.withDensityᵥ g
i : Set α
hi : MeasurableSet i
x✝ : μ i < ⊤
⊢ ∫ (x : α) in i, f x ∂μ = ∫ (x : α) in i, g x ∂μ

tactic: rw [← withDensityᵥ_apply hf hi, hfg, withDensityᵥ_apply hg hi]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : μ.withDensityᵥ f = μ.withDensityᵥ g
i : Set α
hi : MeasurableSet i
x✝ : μ i < ⊤
⊢ ∫ (x : α) in i, f x ∂μ = ∫ (x : α) in i, g x ∂μ
state_after: no goals
Theorem: Cardinal.blsub_lt_ord_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [hc.cof_eq]
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{max u_2 u_3}
f : (a : Ordinal.{max u_2 u_3}) → a < o → Ordinal.{max u_2 u_3}
c : Cardinal.{max u_2 u_3}
hc : c.IsRegular
ho : o.card < c
⊢ o.card < c.ord.cof
state_after: no goals
Theorem: List.form_perm_zpow_apply_mem_imp_mem
File: Mathlib/GroupTheory/Perm/List.lean

tactic: by_cases h : (l.formPerm ^ n) x = x
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
⊢ (l.formPerm ^ n) x ∈ l
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h : (l.formPerm ^ n) x = x
⊢ (l.formPerm ^ n) x ∈ l

case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h : ¬(l.formPerm ^ n) x = x
⊢ (l.formPerm ^ n) x ∈ l

tactic: simpa [h] using hx
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h : (l.formPerm ^ n) x = x
⊢ (l.formPerm ^ n) x ∈ l
state_after: no goals

tactic: have h : x ∈ { x | (l.formPerm ^ n) x ≠ x } := h
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h : ¬(l.formPerm ^ n) x = x
⊢ (l.formPerm ^ n) x ∈ l
state_after: case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬(l.formPerm ^ n) x = x
h : x ∈ {x | (l.formPerm ^ n) x ≠ x}
⊢ (l.formPerm ^ n) x ∈ l

tactic: rw [← set_support_apply_mem] at h
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬(l.formPerm ^ n) x = x
h : x ∈ {x | (l.formPerm ^ n) x ≠ x}
⊢ (l.formPerm ^ n) x ∈ l
state_after: case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬(l.formPerm ^ n) x = x
h : (l.formPerm ^ n) x ∈ {x | (l.formPerm ^ n) x ≠ x}
⊢ (l.formPerm ^ n) x ∈ l

tactic: replace h := set_support_zpow_subset _ _ h
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬(l.formPerm ^ n) x = x
h : (l.formPerm ^ n) x ∈ {x | (l.formPerm ^ n) x ≠ x}
⊢ (l.formPerm ^ n) x ∈ l
state_after: case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬(l.formPerm ^ n) x = x
h : (l.formPerm ^ n) x ∈ {x | l.formPerm x ≠ x}
⊢ (l.formPerm ^ n) x ∈ l

tactic: simpa using support_formPerm_le' _ h
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
hx : x ∈ l
n : ℤ
h✝ : ¬(l.formPerm ^ n) x = x
h : (l.formPerm ^ n) x ∈ {x | l.formPerm x ≠ x}
⊢ (l.formPerm ^ n) x ∈ l
state_after: no goals
Theorem: Int.dvd_of_dvd_mul_left_of_gcd_one
File: Mathlib/Data/Int/GCD.lean

tactic: have := gcd_eq_gcd_ab a c
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : ↑(a.gcd c) = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b

tactic: simp only [hab, Int.ofNat_zero, Int.ofNat_succ, zero_add] at this
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : ↑(a.gcd c) = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : 1 = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b

tactic: have : b * a * gcdA a c + b * c * gcdB a c = b := by simp [mul_assoc, ← Int.mul_add, ← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : 1 = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b

tactic: rw [← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b * a * a.gcdA c + b * c * a.gcdB c

tactic: exact Int.dvd_add (dvd_mul_of_dvd_left (dvd_mul_left a b) _) (dvd_mul_of_dvd_left habc _)
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b * a * a.gcdA c + b * c * a.gcdB c
state_after: no goals

tactic: simp [mul_assoc, ← Int.mul_add, ← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : 1 = a * a.gcdA c + c * a.gcdB c
⊢ b * a * a.gcdA c + b * c * a.gcdB c = b
state_after: no goals
Theorem: CategoryTheory.eqToIso_map_trans
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
p : X = Y
q : Y = Z
⊢ F.mapIso (eqToIso p) ≪≫ F.mapIso (eqToIso q) = F.mapIso (eqToIso ⋯)
state_after: no goals
Theorem: Sum.sum_rec_congr
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
P : α ⊕ β → Sort u_3
f : (i : α) → P (inl i)
g : (i : β) → P (inr i)
x y : α ⊕ β
h : x = y
⊢ rec f g x = cast ⋯ (rec f g y)
state_after: case refl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
P : α ⊕ β → Sort u_3
f : (i : α) → P (inl i)
g : (i : β) → P (inr i)
x : α ⊕ β
⊢ rec f g x = cast ⋯ (rec f g x)

tactic: rfl
state_before: case refl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
P : α ⊕ β → Sort u_3
f : (i : α) → P (inl i)
g : (i : β) → P (inr i)
x : α ⊕ β
⊢ rec f g x = cast ⋯ (rec f g x)
state_after: no goals
Theorem: List.cyclicPermutations_injective
File: Mathlib/Data/List/Rotate.lean

tactic: simpa using congr_arg head? h
state_before: α : Type u
l✝ l'✝ l l' : List α
h : l.cyclicPermutations = l'.cyclicPermutations
⊢ l = l'
state_after: no goals
Theorem: AlgebraicGeometry.ΓSpec.adjunction_unit_app_app_top
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

tactic: have := ΓSpec.adjunction.left_triangle_components X
state_before: X : Scheme
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this :
  Scheme.Γ.rightOp.map (adjunction.unit.app X) ≫ adjunction.counit.app (Scheme.Γ.rightOp.obj X) =
    𝟙 (Scheme.Γ.rightOp.obj X)
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom

tactic: dsimp at this
state_before: X : Scheme
this :
  Scheme.Γ.rightOp.map (adjunction.unit.app X) ≫ adjunction.counit.app (Scheme.Γ.rightOp.obj X) =
    𝟙 (Scheme.Γ.rightOp.obj X)
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op ≫ (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op = 𝟙 { unop := Γ(X, ⊤) }
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom

tactic: rw [← IsIso.eq_comp_inv] at this
state_before: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op ≫ (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op = 𝟙 { unop := Γ(X, ⊤) }
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = 𝟙 { unop := Γ(X, ⊤) } ≫ inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom

tactic: simp only [adjunction_counit_app, Functor.id_obj, Functor.comp_obj, Functor.rightOp_obj,
  Scheme.Γ_obj, Category.id_comp] at this
state_before: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = 𝟙 { unop := Γ(X, ⊤) } ≫ inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom

tactic: rw [← Quiver.Hom.op_inj.eq_iff, this, ← op_inv, IsIso.Iso.inv_inv]
state_before: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: no goals
Theorem: Filter.limsInf_top
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [eq_univ_iff_forall]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
⊢ ∀ b ∈ {a | ∀ᶠ (n : α) in ⊤, a ≤ n}, b ≤ ⊥
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
⊢ ∀ (b : α), (∀ (x : α), b ≤ x) → b = ⊥

tactic: exact fun b hb => bot_unique <| hb _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
⊢ ∀ (b : α), (∀ (x : α), b ≤ x) → b = ⊥
state_after: no goals
Theorem: SimpleGraph.degree_eq_sum_if_adj
File: Mathlib/Combinatorics/SimpleGraph/LapMatrix.lean

tactic: unfold degree neighborFinset neighborSet
state_before: V : Type u_1
R : Type u_2
inst✝³ : Fintype V
inst✝² : DecidableEq V
G : SimpleGraph V
inst✝¹ : DecidableRel G.Adj
inst✝ : AddCommMonoidWithOne R
i : V
⊢ ↑(G.degree i) = ∑ j : V, if G.Adj i j then 1 else 0
state_after: V : Type u_1
R : Type u_2
inst✝³ : Fintype V
inst✝² : DecidableEq V
G : SimpleGraph V
inst✝¹ : DecidableRel G.Adj
inst✝ : AddCommMonoidWithOne R
i : V
⊢ ↑{w | G.Adj i w}.toFinset.card = ∑ j : V, if G.Adj i j then 1 else 0

tactic: rw [sum_boole, Set.toFinset_setOf]
state_before: V : Type u_1
R : Type u_2
inst✝³ : Fintype V
inst✝² : DecidableEq V
G : SimpleGraph V
inst✝¹ : DecidableRel G.Adj
inst✝ : AddCommMonoidWithOne R
i : V
⊢ ↑{w | G.Adj i w}.toFinset.card = ∑ j : V, if G.Adj i j then 1 else 0
state_after: no goals
Theorem: QuadraticForm.map_smul_of_tower
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← IsScalarTower.algebraMap_smul R a x, map_smul, ← RingHom.map_mul, Algebra.smul_def]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
Q : QuadraticForm R M
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Module S M
inst✝ : IsScalarTower S R M
a : S
x : M
⊢ Q (a • x) = (a * a) • Q x
state_after: no goals
Theorem: Complex.ringHom_eq_id_or_conj_of_continuous
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa only [DFunLike.ext_iff] using real_algHom_eq_id_or_conj (AlgHom.mk' f (map_real_smul f hf))
state_before: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ →+* ℂ
hf : Continuous ⇑f
⊢ f = RingHom.id ℂ ∨ f = starRingEnd ℂ
state_after: no goals
Theorem: IsPrimitiveRoot.integralPowerBasis'_gen
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

tactic: convert hcycl
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ IsCyclotomicExtension {p ^ 1} ℚ K
state_after: case h.e'_1.h.e'_4
p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ p ^ 1 = p

tactic: rw [pow_one]
state_before: case h.e'_1.h.e'_4
p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ p ^ 1 = p
state_after: no goals

tactic: rwa [pow_one]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ IsPrimitiveRoot ζ ↑(p ^ 1)
state_after: no goals