1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Submodule.dualCoannihilator_map_linearEquiv_flip
File: Mathlib/LinearAlgebra/PerfectPairing.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R M
⊢ (map e.flip p).dualCoannihilator = map e.symm p.dualAnnihilator
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R M
x✝ : N
⊢ x✝ ∈ (map e.flip p).dualCoannihilator ↔ x✝ ∈ map e.symm p.dualAnnihilator

tactic: simp [LinearEquiv.symm_apply_eq, Submodule.mem_dualCoannihilator]
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R M
x✝ : N
⊢ x✝ ∈ (map e.flip p).dualCoannihilator ↔ x✝ ∈ map e.symm p.dualAnnihilator
state_after: no goals
Theorem: Int.Matrix.card_T_eq
File: Mathlib/NumberTheory/SiegelsLemma.lean

tactic: rw [Pi.card_Icc 0 B']
state_before: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
⊢ T.card = (B + 1) ^ n
state_after: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
⊢ ∏ i : Fin n, (Icc (0 i) ↑B).card = (B + 1) ^ n

tactic: simp only [Pi.zero_apply, Int.card_Icc, sub_zero, Int.toNat_ofNat_add_one, prod_const, card_fin]
state_before: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
⊢ ∏ i : Fin n, (Icc (0 i) ↑B).card = (B + 1) ^ n
state_after: no goals
Theorem: FirstOrder.Language.Embedding.toHom_comp_injective
File: Mathlib/ModelTheory/Basic.lean

tactic: intro f g hfg
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : N ↪[L] P
⊢ Function.Injective h.toHom.comp
state_after: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : N ↪[L] P
f g : M →[L] N
hfg : h.toHom.comp f = h.toHom.comp g
⊢ f = g

tactic: ext x
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : N ↪[L] P
f g : M →[L] N
hfg : h.toHom.comp f = h.toHom.comp g
⊢ f = g
state_after: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : N ↪[L] P
f g : M →[L] N
hfg : h.toHom.comp f = h.toHom.comp g
x : M
⊢ f x = g x

tactic: exact h.injective (DFunLike.congr_fun hfg x)
state_before: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : N ↪[L] P
f g : M →[L] N
hfg : h.toHom.comp f = h.toHom.comp g
x : M
⊢ f x = g x
state_after: no goals
Theorem: Rat.add_den_dvd
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [add_def, normalize_eq]
state_before: q₁ q₂ : ℚ
⊢ (q₁ + q₂).den ∣ q₁.den * q₂.den
state_after: q₁ q₂ : ℚ
⊢ {
        num :=
          (q₁.num * ↑q₂.den + q₂.num * ↑q₁.den) / ↑((q₁.num * ↑q₂.den + q₂.num * ↑q₁.den).natAbs.gcd (q₁.den * q₂.den)),
        den := q₁.den * q₂.den / (q₁.num * ↑q₂.den + q₂.num * ↑q₁.den).natAbs.gcd (q₁.den * q₂.den), den_nz := ⋯,
        reduced := ⋯ }.den ∣
    q₁.den * q₂.den

tactic: apply Nat.div_dvd_of_dvd
state_before: q₁ q₂ : ℚ
⊢ {
        num :=
          (q₁.num * ↑q₂.den + q₂.num * ↑q₁.den) / ↑((q₁.num * ↑q₂.den + q₂.num * ↑q₁.den).natAbs.gcd (q₁.den * q₂.den)),
        den := q₁.den * q₂.den / (q₁.num * ↑q₂.den + q₂.num * ↑q₁.den).natAbs.gcd (q₁.den * q₂.den), den_nz := ⋯,
        reduced := ⋯ }.den ∣
    q₁.den * q₂.den
state_after: case h
q₁ q₂ : ℚ
⊢ (q₁.num * ↑q₂.den + q₂.num * ↑q₁.den).natAbs.gcd (q₁.den * q₂.den) ∣ q₁.den * q₂.den

tactic: apply Nat.gcd_dvd_right
state_before: case h
q₁ q₂ : ℚ
⊢ (q₁.num * ↑q₂.den + q₂.num * ↑q₁.den).natAbs.gcd (q₁.den * q₂.den) ∣ q₁.den * q₂.den
state_after: no goals
Theorem: levenshtein_nil_nil
File: Mathlib/Data/List/EditDistance/Defs.lean

tactic: simp [levenshtein, suffixLevenshtein]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
⊢ levenshtein C [] [] = 0
state_after: no goals
Theorem: LieSubmodule.map_bot
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: ext m
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
⊢ map f ⊥ = ⊥
state_after: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m : M'
⊢ m ∈ map f ⊥ ↔ m ∈ ⊥

tactic: simp [eq_comm]
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m : M'
⊢ m ∈ map f ⊥ ↔ m ∈ ⊥
state_after: no goals
Theorem: WittVector.mapFun.natCast
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: induction n <;> simp [*, Nat.unaryCast, add, one, zero] <;> rfl
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : R →+* S
x y : 𝕎 R
n : ℕ
⊢ mapFun (⇑f) n.unaryCast = ↑n
state_after: no goals
Theorem: CategoryTheory.Equivalence.counit_app_functor
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: erw [← Iso.hom_comp_eq_id (e.functor.mapIso (e.unitIso.app X)), functor_unit_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ e.counit.app (e.functor.obj X) = e.functor.map (e.unitInv.app X)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ 𝟙 (e.functor.obj X) = 𝟙 (e.functor.obj ((𝟭 C).obj X))

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ 𝟙 (e.functor.obj X) = 𝟙 (e.functor.obj ((𝟭 C).obj X))
state_after: no goals
Theorem: ProjectiveSpectrum.gc_set
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: have ideal_gc : GaloisConnection Ideal.span _ := (Submodule.gi A _).gc
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
⊢ GaloisConnection (fun s => zeroLocus 𝒜 s) fun t => ↑(vanishingIdeal t)
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
ideal_gc : GaloisConnection Ideal.span SetLike.coe
⊢ GaloisConnection (fun s => zeroLocus 𝒜 s) fun t => ↑(vanishingIdeal t)

tactic: simpa [zeroLocus_span, Function.comp] using GaloisConnection.compose ideal_gc (gc_ideal 𝒜)
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
ideal_gc : GaloisConnection Ideal.span SetLike.coe
⊢ GaloisConnection (fun s => zeroLocus 𝒜 s) fun t => ↑(vanishingIdeal t)
state_after: no goals
Theorem: Set.Iio_diff_Iio
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [diff_eq, compl_Iio, inter_comm, Ici_inter_Iio]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
⊢ Iio b \ Iio a = Ico a b
state_after: no goals
Theorem: Tropical.add_eq_zero_iff
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: rw [add_eq_iff]
state_before: R : Type u
inst✝ : LinearOrder R
a b : Tropical (WithTop R)
⊢ a + b = 0 ↔ a = 0 ∧ b = 0
state_after: R : Type u
inst✝ : LinearOrder R
a b : Tropical (WithTop R)
⊢ a = 0 ∧ a ≤ b ∨ b = 0 ∧ b ≤ a ↔ a = 0 ∧ b = 0

tactic: constructor
state_before: R : Type u
inst✝ : LinearOrder R
a b : Tropical (WithTop R)
⊢ a = 0 ∧ a ≤ b ∨ b = 0 ∧ b ≤ a ↔ a = 0 ∧ b = 0
state_after: case mp
R : Type u
inst✝ : LinearOrder R
a b : Tropical (WithTop R)
⊢ a = 0 ∧ a ≤ b ∨ b = 0 ∧ b ≤ a → a = 0 ∧ b = 0

case mpr
R : Type u
inst✝ : LinearOrder R
a b : Tropical (WithTop R)
⊢ a = 0 ∧ b = 0 → a = 0 ∧ a ≤ b ∨ b = 0 ∧ b ≤ a

tactic: rintro (⟨rfl, h⟩ | ⟨rfl, h⟩)
state_before: case mp
R : Type u
inst✝ : LinearOrder R
a b : Tropical (WithTop R)
⊢ a = 0 ∧ a ≤ b ∨ b = 0 ∧ b ≤ a → a = 0 ∧ b = 0
state_after: case mp.inl.intro
R : Type u
inst✝ : LinearOrder R
b : Tropical (WithTop R)
h : 0 ≤ b
⊢ 0 = 0 ∧ b = 0

case mp.inr.intro
R : Type u
inst✝ : LinearOrder R
a : Tropical (WithTop R)
h : 0 ≤ a
⊢ a = 0 ∧ 0 = 0

tactic: exact ⟨rfl, le_antisymm (le_zero _) h⟩
state_before: case mp.inl.intro
R : Type u
inst✝ : LinearOrder R
b : Tropical (WithTop R)
h : 0 ≤ b
⊢ 0 = 0 ∧ b = 0
state_after: no goals

tactic: exact ⟨le_antisymm (le_zero _) h, rfl⟩
state_before: case mp.inr.intro
R : Type u
inst✝ : LinearOrder R
a : Tropical (WithTop R)
h : 0 ≤ a
⊢ a = 0 ∧ 0 = 0
state_after: no goals

tactic: rintro ⟨rfl, rfl⟩
state_before: case mpr
R : Type u
inst✝ : LinearOrder R
a b : Tropical (WithTop R)
⊢ a = 0 ∧ b = 0 → a = 0 ∧ a ≤ b ∨ b = 0 ∧ b ≤ a
state_after: case mpr.intro
R : Type u
inst✝ : LinearOrder R
⊢ 0 = 0 ∧ 0 ≤ 0 ∨ 0 = 0 ∧ 0 ≤ 0

tactic: simp
state_before: case mpr.intro
R : Type u
inst✝ : LinearOrder R
⊢ 0 = 0 ∧ 0 ≤ 0 ∨ 0 = 0 ∧ 0 ≤ 0
state_after: no goals
Theorem: PEquiv.single_mul_single
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: rw [← toMatrix_trans, single_trans_single]
state_before: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq k
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
a : m
b : n
c : k
⊢ (single a b).toMatrix * (single b c).toMatrix = (single a c).toMatrix
state_after: no goals
Theorem: AffineSubspace.SOppSide.oangle_sign_eq_neg
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

tactic: have hp₁p₃ : p₁ ≠ p₃ := by rintro rfl; exact hp₃p₄.left_not_mem hp₁
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : AffineSubspace ℝ P
p₁ p₂ p₃ p₄ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃p₄ : s.SOppSide p₃ p₄
⊢ (∡ p₁ p₄ p₂).sign = -(∡ p₁ p₃ p₂).sign
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : AffineSubspace ℝ P
p₁ p₂ p₃ p₄ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃p₄ : s.SOppSide p₃ p₄
hp₁p₃ : p₁ ≠ p₃
⊢ (∡ p₁ p₄ p₂).sign = -(∡ p₁ p₃ p₂).sign

tactic: rw [← (hp₃p₄.symm.trans (sOppSide_pointReflection hp₁ hp₃p₄.left_not_mem)).oangle_sign_eq hp₁ hp₂,
  ← oangle_rotate_sign p₁, ← oangle_rotate_sign p₁, oangle_swap₁₃_sign,
  (sbtw_pointReflection_of_ne ℝ hp₁p₃).symm.oangle_sign_eq _]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : AffineSubspace ℝ P
p₁ p₂ p₃ p₄ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃p₄ : s.SOppSide p₃ p₄
hp₁p₃ : p₁ ≠ p₃
⊢ (∡ p₁ p₄ p₂).sign = -(∡ p₁ p₃ p₂).sign
state_after: no goals

tactic: rintro rfl
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : AffineSubspace ℝ P
p₁ p₂ p₃ p₄ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃p₄ : s.SOppSide p₃ p₄
⊢ p₁ ≠ p₃
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : AffineSubspace ℝ P
p₁ p₂ p₄ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃p₄ : s.SOppSide p₁ p₄
⊢ False

tactic: exact hp₃p₄.left_not_mem hp₁
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : AffineSubspace ℝ P
p₁ p₂ p₄ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃p₄ : s.SOppSide p₁ p₄
⊢ False
state_after: no goals
Theorem: Rat.add_mul
File: Mathlib/Data/Rat/Defs.lean

tactic: simp only [ne_eq, Int.natCast_eq_zero, h₁, not_false_eq_true, h₂, divInt_add_divInt,
  Int.mul_eq_zero, or_self, h₃, divInt_mul_divInt]
state_before: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ /. ↑d₁ + n₂ /. ↑d₂) * (n₃ /. ↑d₃) = n₁ /. ↑d₁ * (n₃ /. ↑d₃) + n₂ /. ↑d₂ * (n₃ /. ↑d₃)
state_after: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ + n₂ * ↑d₁) * n₃ /. (↑d₁ * ↑d₂ * ↑d₃) =
    (n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))

tactic: rw [← divInt_mul_right (Int.natCast_ne_zero.2 h₃), Int.add_mul, Int.add_mul]
state_before: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ + n₂ * ↑d₁) * n₃ /. (↑d₁ * ↑d₂ * ↑d₃) =
    (n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))
state_after: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ * n₃ * ↑d₃ + n₂ * ↑d₁ * n₃ * ↑d₃) /. (↑d₁ * ↑d₂ * ↑d₃ * ↑d₃) =
    (n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))

tactic: ac_rfl
state_before: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ * n₃ * ↑d₃ + n₂ * ↑d₁ * n₃ * ↑d₃) /. (↑d₁ * ↑d₂ * ↑d₃ * ↑d₃) =
    (n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))
state_after: no goals
Theorem: LaurentPolynomial.degree_T_le
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: rw [map_one, one_mul]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
⊢ (T n).degree = (C 1 * T n).degree
state_after: no goals
Theorem: Filter.disjoint_pure_pure
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [← principal_singleton, disjoint_principal_principal, disjoint_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
x y : α
⊢ Disjoint (pure x) (pure y) ↔ x ≠ y
state_after: no goals
Theorem: MeasurableEmbedding.integrableOn_map_iff
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: simp_rw [IntegrableOn, he.restrict_map, he.integrable_map_iff]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure α
s : Set β
⊢ IntegrableOn f s (Measure.map e μ) ↔ IntegrableOn (f ∘ e) (e ⁻¹' s) μ
state_after: no goals
Theorem: Nat.sq_add_sq_mul
File: Mathlib/NumberTheory/SumTwoSquares.lean

tactic: zify at ha hb ⊢
state_before: a b x y u v : ℕ
ha : a = x ^ 2 + y ^ 2
hb : b = u ^ 2 + v ^ 2
⊢ ∃ r s, a * b = r ^ 2 + s ^ 2
state_after: a b x y u v : ℕ
ha : ↑a = ↑x ^ 2 + ↑y ^ 2
hb : ↑b = ↑u ^ 2 + ↑v ^ 2
⊢ ∃ r s, ↑a * ↑b = ↑r ^ 2 + ↑s ^ 2

tactic: obtain ⟨r, s, h⟩ := _root_.sq_add_sq_mul ha hb
state_before: a b x y u v : ℕ
ha : ↑a = ↑x ^ 2 + ↑y ^ 2
hb : ↑b = ↑u ^ 2 + ↑v ^ 2
⊢ ∃ r s, ↑a * ↑b = ↑r ^ 2 + ↑s ^ 2
state_after: case intro.intro
a b x y u v : ℕ
ha : ↑a = ↑x ^ 2 + ↑y ^ 2
hb : ↑b = ↑u ^ 2 + ↑v ^ 2
r s : ℤ
h : ↑a * ↑b = r ^ 2 + s ^ 2
⊢ ∃ r s, ↑a * ↑b = ↑r ^ 2 + ↑s ^ 2

tactic: refine ⟨r.natAbs, s.natAbs, ?_⟩
state_before: case intro.intro
a b x y u v : ℕ
ha : ↑a = ↑x ^ 2 + ↑y ^ 2
hb : ↑b = ↑u ^ 2 + ↑v ^ 2
r s : ℤ
h : ↑a * ↑b = r ^ 2 + s ^ 2
⊢ ∃ r s, ↑a * ↑b = ↑r ^ 2 + ↑s ^ 2
state_after: case intro.intro
a b x y u v : ℕ
ha : ↑a = ↑x ^ 2 + ↑y ^ 2
hb : ↑b = ↑u ^ 2 + ↑v ^ 2
r s : ℤ
h : ↑a * ↑b = r ^ 2 + s ^ 2
⊢ ↑a * ↑b = ↑r.natAbs ^ 2 + ↑s.natAbs ^ 2

tactic: simpa only [Int.natCast_natAbs, sq_abs]
state_before: case intro.intro
a b x y u v : ℕ
ha : ↑a = ↑x ^ 2 + ↑y ^ 2
hb : ↑b = ↑u ^ 2 + ↑v ^ 2
r s : ℤ
h : ↑a * ↑b = r ^ 2 + s ^ 2
⊢ ↑a * ↑b = ↑r.natAbs ^ 2 + ↑s.natAbs ^ 2
state_after: no goals
Theorem: Subgroup.comap_normalizer_eq_of_surjective
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: intro x hx
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
⊢ (comap f H).normalizer ≤ comap f H.normalizer
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : x ∈ (comap f H).normalizer
⊢ x ∈ comap f H.normalizer

tactic: simp only [mem_comap, mem_normalizer_iff] at *
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : x ∈ (comap f H).normalizer
⊢ x ∈ comap f H.normalizer
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : ∀ (h : N), f h ∈ H ↔ f (x * h * x⁻¹) ∈ H
⊢ ∀ (h : G), h ∈ H ↔ f x * h * (f x)⁻¹ ∈ H

tactic: intro n
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : ∀ (h : N), f h ∈ H ↔ f (x * h * x⁻¹) ∈ H
⊢ ∀ (h : G), h ∈ H ↔ f x * h * (f x)⁻¹ ∈ H
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : ∀ (h : N), f h ∈ H ↔ f (x * h * x⁻¹) ∈ H
n : G
⊢ n ∈ H ↔ f x * n * (f x)⁻¹ ∈ H

tactic: rcases hf n with ⟨y, rfl⟩
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : ∀ (h : N), f h ∈ H ↔ f (x * h * x⁻¹) ∈ H
n : G
⊢ n ∈ H ↔ f x * n * (f x)⁻¹ ∈ H
state_after: case intro
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : ∀ (h : N), f h ∈ H ↔ f (x * h * x⁻¹) ∈ H
y : N
⊢ f y ∈ H ↔ f x * f y * (f x)⁻¹ ∈ H

tactic: simp [hx y]
state_before: case intro
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : N →* G
hf : Surjective ⇑f
x : N
hx : ∀ (h : N), f h ∈ H ↔ f (x * h * x⁻¹) ∈ H
y : N
⊢ f y ∈ H ↔ f x * f y * (f x)⁻¹ ∈ H
state_after: no goals
Theorem: Filter.Germ.coe_lt
File: Mathlib/Order/Filter/FilterProduct.lean

tactic: simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, EventuallyLE]
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : Preorder β
f g : α → β
⊢ ↑f < ↑g ↔ ∀* (x : α), f x < g x
state_after: no goals
Theorem: ProbabilityTheory.condIndepFun_iff_condIndep
File: Mathlib/Probability/Independence/Conditional.lean

tactic: simp only [CondIndepFun, CondIndep, kernel.IndepFun]
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : Type u_3
γ : Type u_4
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : Ω → β
g : Ω → γ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ CondIndepFun m' hm' f g μ ↔ CondIndep m' (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) hm' μ
state_after: no goals
Theorem: isUnit_gcd_of_eq_mul_gcd
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rw [← associated_one_iff_isUnit]
state_before: α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y x' y' : α
ex : x = gcd x y * x'
ey : y = gcd x y * y'
h : gcd x y ≠ 0
⊢ IsUnit (gcd x' y')
state_after: α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y x' y' : α
ex : x = gcd x y * x'
ey : y = gcd x y * y'
h : gcd x y ≠ 0
⊢ Associated (gcd x' y') 1

tactic: refine Associated.of_mul_left ?_ (Associated.refl <| gcd x y) h
state_before: α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y x' y' : α
ex : x = gcd x y * x'
ey : y = gcd x y * y'
h : gcd x y ≠ 0
⊢ Associated (gcd x' y') 1
state_after: α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y x' y' : α
ex : x = gcd x y * x'
ey : y = gcd x y * y'
h : gcd x y ≠ 0
⊢ Associated (gcd x y * gcd x' y') (gcd x y * 1)

tactic: convert (gcd_mul_left' (gcd x y) x' y').symm using 1
state_before: α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y x' y' : α
ex : x = gcd x y * x'
ey : y = gcd x y * y'
h : gcd x y ≠ 0
⊢ Associated (gcd x y * gcd x' y') (gcd x y * 1)
state_after: case h.e'_4
α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y x' y' : α
ex : x = gcd x y * x'
ey : y = gcd x y * y'
h : gcd x y ≠ 0
⊢ gcd x y * 1 = gcd (gcd x y * x') (gcd x y * y')

tactic: rw [← ex, ← ey, mul_one]
state_before: case h.e'_4
α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y x' y' : α
ex : x = gcd x y * x'
ey : y = gcd x y * y'
h : gcd x y ≠ 0
⊢ gcd x y * 1 = gcd (gcd x y * x') (gcd x y * y')
state_after: no goals
Theorem: IsKleinFour.inv_eq_self
File: Mathlib/GroupTheory/SpecificGroups/KleinFour.lean

tactic: simp
state_before: G : Type u_1
inst✝¹ : Group G
inst✝ : IsKleinFour G
x : G
⊢ Monoid.exponent G = 2
state_after: no goals