1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.factorization_eq_zero_iff'
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [factorization_eq_factors_multiset n]
state_before: a b m n✝ p n : ℕ
⊢ n.factorization = 0 ↔ n = 0 ∨ n = 1
state_after: a b m n✝ p n : ℕ
⊢ Multiset.toFinsupp ↑n.factors = 0 ↔ n = 0 ∨ n = 1

tactic: simp [factorization, AddEquiv.map_eq_zero_iff, Multiset.coe_eq_zero]
state_before: a b m n✝ p n : ℕ
⊢ Multiset.toFinsupp ↑n.factors = 0 ↔ n = 0 ∨ n = 1
state_after: no goals
Theorem: Function.Exact.exact_mapQ_iff
File: Mathlib/Algebra/Exact.lean

tactic: rw [exact_iff, ← (comap_injective_of_surjective (mkQ_surjective _)).eq_iff]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ Exact ⇑(p.mapQ q f hpq) ⇑(q.mapQ r g hqr) ↔ range g ⊓ r ≤ map g q
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.mapQ r g hqr)) = comap q.mkQ (range (p.mapQ q f hpq)) ↔ range g ⊓ r ≤ map g q

tactic: dsimp only [mapQ]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.mapQ r g hqr)) = comap q.mkQ (range (p.mapQ q f hpq)) ↔ range g ⊓ r ≤ map g q
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.liftQ (r.mkQ ∘ₗ g) ⋯)) = comap q.mkQ (range (p.liftQ (q.mkQ ∘ₗ f) ⋯)) ↔ range g ⊓ r ≤ map g q

tactic: rw [← ker_comp, range_liftQ, liftQ_mkQ, ker_comp, range_comp, comap_map_eq,
  ker_mkQ, ker_mkQ, ← hfg.linearMap_ker_eq, sup_comm,
  ← LE.le.le_iff_eq (sup_le hqr (ker_le_comap g)),
  ← comap_map_eq, ← map_le_iff_le_comap, map_comap_eq]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.liftQ (r.mkQ ∘ₗ g) ⋯)) = comap q.mkQ (range (p.liftQ (q.mkQ ∘ₗ f) ⋯)) ↔ range g ⊓ r ≤ map g q
state_after: no goals
Theorem: Finset.preimage_mul_left_one
File: Mathlib/Data/Finset/Pointwise.lean

tactic: classical rw [← image_mul_left', image_one, mul_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Finset α
a b : α
⊢ preimage 1 (fun x => a * x) ⋯ = {a⁻¹}
state_after: no goals

tactic: rw [← image_mul_left', image_one, mul_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Finset α
a b : α
⊢ preimage 1 (fun x => a * x) ⋯ = {a⁻¹}
state_after: no goals
Theorem: Polynomial.aeval_eq_zero_of_dvd_aeval_eq_zero
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

tactic: rw [aeval_def, ← eval_map] at h₂ ⊢
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a✝ b : R
n : ℕ
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : CommSemiring A'
inst✝⁶ : Semiring B
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R A'
inst✝³ : Algebra R B
p✝ q✝ : R[X]
x : A
inst✝² : CommSemiring S
inst✝¹ : CommSemiring T
inst✝ : Algebra S T
p q : S[X]
h₁ : p ∣ q
a : T
h₂ : (aeval a) p = 0
⊢ (aeval a) q = 0
state_after: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a✝ b : R
n : ℕ
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : CommSemiring A'
inst✝⁶ : Semiring B
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R A'
inst✝³ : Algebra R B
p✝ q✝ : R[X]
x : A
inst✝² : CommSemiring S
inst✝¹ : CommSemiring T
inst✝ : Algebra S T
p q : S[X]
h₁ : p ∣ q
a : T
h₂ : eval a (map (algebraMap S T) p) = 0
⊢ eval a (map (algebraMap S T) q) = 0

tactic: exact eval_eq_zero_of_dvd_of_eval_eq_zero (Polynomial.map_dvd (algebraMap S T) h₁) h₂
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a✝ b : R
n : ℕ
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : CommSemiring A'
inst✝⁶ : Semiring B
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R A'
inst✝³ : Algebra R B
p✝ q✝ : R[X]
x : A
inst✝² : CommSemiring S
inst✝¹ : CommSemiring T
inst✝ : Algebra S T
p q : S[X]
h₁ : p ∣ q
a : T
h₂ : eval a (map (algebraMap S T) p) = 0
⊢ eval a (map (algebraMap S T) q) = 0
state_after: no goals
Theorem: Part.bind_some_right
File: Mathlib/Data/Part.lean

tactic: erw [bind_some_eq_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
x : Part α
⊢ x.bind some = x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
x : Part α
⊢ map (fun a => a) x = x

tactic: simp [map_id']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
x : Part α
⊢ map (fun a => a) x = x
state_after: no goals
Theorem: CategoryTheory.Functor.map_dite
File: Mathlib/CategoryTheory/Functor/Basic.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F : C ⥤ D
X Y : C
P : Prop
inst✝ : Decidable P
f : P → (X ⟶ Y)
g : ¬P → (X ⟶ Y)
⊢ F.map (if h : P then f h else g h) = if h : P then F.map (f h) else F.map (g h)
state_after: no goals
Theorem: Real.sqrt_mul_self_eq_abs
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← abs_mul_abs_self x, sqrt_mul_self (abs_nonneg _)]
state_before: x✝ y x : ℝ
⊢ √(x * x) = |x|
state_after: no goals
Theorem: CategoryTheory.Localization.Construction.natTransExtension_hcomp
File: Mathlib/CategoryTheory/Localization/Construction.lean

tactic: aesop_cat
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G✝ : C ⥤ D
hG : W.IsInvertedBy G✝
F G : W.Localization ⥤ D
τ : W.Q ⋙ F ⟶ W.Q ⋙ G
⊢ 𝟙 W.Q ◫ natTransExtension τ = τ
state_after: no goals
Theorem: CochainComplex.mappingCone.desc_f
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: omega
state_before: C : Type u_1
inst✝² : Category.{?u.153881, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cochain F K (-1)
β : G ⟶ K
eq : δ (-1) 0 α = Cochain.ofHom (φ ≫ β)
p q : ℤ
hpq : p + 1 = q
⊢ q + -1 = p
state_after: no goals

tactic: simp [ext_from_iff _ _ _ hpq]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cochain F K (-1)
β : G ⟶ K
eq : δ (-1) 0 α = Cochain.ofHom (φ ≫ β)
p q : ℤ
hpq : p + 1 = q
⊢ (desc φ α β eq).f p = (↑(fst φ)).v p q hpq ≫ α.v q p ⋯ + (snd φ).v p p ⋯ ≫ β.f p
state_after: no goals
Theorem: Complex.rank_real_complex
File: Mathlib/Data/Complex/FiniteDimensional.lean

tactic: simp [← finrank_eq_rank, finrank_real_complex]
state_before: ⊢ Module.rank ℝ ℂ = 2
state_after: no goals
Theorem: List.nextOr_cons_of_ne
File: Mathlib/Data/List/Cycle.lean

tactic: cases' xs with z zs
state_before: α : Type u_1
inst✝ : DecidableEq α
xs : List α
y x d : α
h : x ≠ y
⊢ (y :: xs).nextOr x d = xs.nextOr x d
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
y x d : α
h : x ≠ y
⊢ [y].nextOr x d = [].nextOr x d

case cons
α : Type u_1
inst✝ : DecidableEq α
y x d : α
h : x ≠ y
z : α
zs : List α
⊢ (y :: z :: zs).nextOr x d = (z :: zs).nextOr x d

tactic: rfl
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
y x d : α
h : x ≠ y
⊢ [y].nextOr x d = [].nextOr x d
state_after: no goals

tactic: exact if_neg h
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
y x d : α
h : x ≠ y
z : α
zs : List α
⊢ (y :: z :: zs).nextOr x d = (z :: zs).nextOr x d
state_after: no goals
Theorem: BoxIntegral.HasIntegral.mcShane_of_forall_isLittleO
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simpa only [McShane, Bool.coe_sort_false, false_imp_iff, true_imp_iff, diff_empty] using H
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ B J
g : ι →ᵇᵃ[↑I] F
H : ℝ≥0 → ∀ x ∈ Box.Icc I, ∀ ε > 0, ∃ δ > 0, ∀ J ≤ I, Box.Icc J ⊆ closedBall x δ → dist ((vol J) (f x)) (g J) ≤ ε * B J
⊢ ∀ (c : ℝ≥0),
    ∀ x ∈ Box.Icc I \ ∅,
      ∀ ε > 0,
        ∃ δ > 0,
          ∀ J ≤ I,
            Box.Icc J ⊆ closedBall x δ →
              (McShane.bHenstock = true → x ∈ Box.Icc J) →
                (McShane.bDistortion = true → J.distortion ≤ c) → dist ((vol J) (f x)) (g J) ≤ ε * B J
state_after: no goals
Theorem: Finset.Icc_mul_Ico_subset'
File: Mathlib/Data/Finset/Pointwise/Interval.lean

tactic: simpa using Set.Icc_mul_Ico_subset' _ _ _ _
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrder α
a b c d : α
⊢ ↑(Icc a b * Ico c d) ⊆ ↑(Ico (a * c) (b * d))
state_after: no goals
Theorem: ZFSet.mem_sep
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rwa [@Quotient.sound PSet _ _ _ h]
state_before: p : ZFSet → Prop
x y✝ : ZFSet
x✝¹ y : PSet
α : Type u
A : α → PSet
x✝ : ⟦y⟧ ∈ ZFSet.sep p ⟦PSet.mk α A⟧
a : (PSet.mk α A).Type
pa : (fun y => p (mk y)) ((PSet.mk α A).Func a)
h : y.Equiv (Func ↑(Resp.f ⟨PSet.sep fun y => p (mk y), ⋯⟩ (PSet.mk α A)) ⟨a, pa⟩)
⊢ p ⟦y⟧
state_after: no goals

tactic: rw [mk_func] at h
state_before: p : ZFSet → Prop
x y✝ : ZFSet
x✝¹ y : PSet
α : Type u
A : α → PSet
x✝ : ⟦y⟧ ∈ ⟦PSet.mk α A⟧ ∧ p ⟦y⟧
a : (PSet.mk α A).Type
h : y.Equiv ((PSet.mk α A).Func a)
pa : p ⟦y⟧
⊢ (fun y => p (mk y)) ((PSet.mk α A).Func a)
state_after: p : ZFSet → Prop
x y✝ : ZFSet
x✝¹ y : PSet
α : Type u
A : α → PSet
x✝ : ⟦y⟧ ∈ ⟦PSet.mk α A⟧ ∧ p ⟦y⟧
a : (PSet.mk α A).Type
h : y.Equiv (A a)
pa : p ⟦y⟧
⊢ p (mk ((PSet.mk α A).Func a))

tactic: rwa [mk_func, ← ZFSet.sound h]
state_before: p : ZFSet → Prop
x y✝ : ZFSet
x✝¹ y : PSet
α : Type u
A : α → PSet
x✝ : ⟦y⟧ ∈ ⟦PSet.mk α A⟧ ∧ p ⟦y⟧
a : (PSet.mk α A).Type
h : y.Equiv (A a)
pa : p ⟦y⟧
⊢ p (mk ((PSet.mk α A).Func a))
state_after: no goals
Theorem: Set.image_neg_Iic
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Iic a = Ici (-a)
state_after: no goals
Theorem: List.mk_add_mem_enumFrom_iff_get?
File: Mathlib/Data/List/Enum.lean

tactic: simp [mem_iff_get?]
state_before: α : Type u_1
β : Type u_2
n i : ℕ
x : α
l : List α
⊢ (n + i, x) ∈ enumFrom n l ↔ l.get? i = some x
state_after: no goals
Theorem: ne_iff_ne_of_mul_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: aesop
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CancelCommMonoid α
a b c d : α
h : a * b = c * d
⊢ a ≠ c ↔ b ≠ d
state_after: no goals
Theorem: Nat.minSqFac_dvd
File: Mathlib/Data/Nat/Squarefree.lean

tactic: have := minSqFac_has_prop n
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
⊢ d * d ∣ n
state_after: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp n.minSqFac
⊢ d * d ∣ n

tactic: rw [h] at this
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp n.minSqFac
⊢ d * d ∣ n
state_after: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp (some d)
⊢ d * d ∣ n

tactic: exact this.2.1
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp (some d)
⊢ d * d ∣ n
state_after: no goals
Theorem: mul_inv_cancel_comm
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [mul_comm, inv_mul_cancel_left]
state_before: G : Type u_1
inst✝ : CommGroup G
a b : G
⊢ a * b * a⁻¹ = b
state_after: no goals
Theorem: preNormEDS'_even
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: rw [show 2 * (m + 3) = 2 * m + 1 + 5 by rfl, preNormEDS', dif_neg m.not_even_two_mul_add_one]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (2 * (m + 3)) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ (let_fun h5 := ⋯;
    preNormEDS' b c d ((2 * m + 1) / 2 + 2) ^ 2 * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 5) -
      preNormEDS' b c d ((2 * m + 1) / 2 + 1) * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 4) ^ 2) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2

tactic: simp only [Nat.mul_add_div two_pos]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ (let_fun h5 := ⋯;
    preNormEDS' b c d ((2 * m + 1) / 2 + 2) ^ 2 * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 5) -
      preNormEDS' b c d ((2 * m + 1) / 2 + 1) * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 4) ^ 2) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (m + 1 / 2 + 2) ^ 2 * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 5) -
      preNormEDS' b c d (m + 1 / 2 + 1) * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 4) ^ 2 =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2

tactic: rfl
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (m + 1 / 2 + 2) ^ 2 * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 5) -
      preNormEDS' b c d (m + 1 / 2 + 1) * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 4) ^ 2 =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
state_after: no goals

tactic: rfl
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ 2 * (m + 3) = 2 * m + 1 + 5
state_after: no goals
Theorem: HasSum.mul_right
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simpa only using hf.map (AddMonoidHom.mulRight a₂) (continuous_id.mul continuous_const)
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂✝ a₂ : α
hf : HasSum f a₁
⊢ HasSum (fun i => f i * a₂) (a₁ * a₂)
state_after: no goals
Theorem: Nat.xgcd_val
File: Mathlib/Data/Int/GCD.lean

tactic: unfold gcdA gcdB
state_before: x y : ℕ
⊢ x.xgcd y = (x.gcdA y, x.gcdB y)
state_after: x y : ℕ
⊢ x.xgcd y = ((x.xgcd y).1, (x.xgcd y).2)

tactic: cases xgcd x y
state_before: x y : ℕ
⊢ x.xgcd y = ((x.xgcd y).1, (x.xgcd y).2)
state_after: case mk
x y : ℕ
fst✝ snd✝ : ℤ
⊢ (fst✝, snd✝) = ((fst✝, snd✝).1, (fst✝, snd✝).2)

tactic: rfl
state_before: case mk
x y : ℕ
fst✝ snd✝ : ℤ
⊢ (fst✝, snd✝) = ((fst✝, snd✝).1, (fst✝, snd✝).2)
state_after: no goals
Theorem: lt_geom
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: apply (monotone_mul_left_of_nonneg hc).seq_pos_lt_seq_of_lt_of_le hn _ h _
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ k < n, u (k + 1) < c * u k
⊢ u n < c ^ n * u 0
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ k < n, u (k + 1) < c * u k
⊢ u 0 ≤ c ^ 0 * u 0

α : Type u_1
β : Type u_2
ι : Type u_3
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ k < n, u (k + 1) < c * u k
⊢ ∀ k < n, c * (c ^ k * u 0) ≤ c ^ (k + 1) * u 0

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ k < n, u (k + 1) < c * u k
⊢ u 0 ≤ c ^ 0 * u 0
state_after: no goals

tactic: simp [_root_.pow_succ', mul_assoc, le_refl]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ k < n, u (k + 1) < c * u k
⊢ ∀ k < n, c * (c ^ k * u 0) ≤ c ^ (k + 1) * u 0
state_after: no goals
Theorem: CliffordAlgebra.contractLeft_one
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: simpa only [map_one] using contractLeft_algebraMap Q d 1
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
⊢ (contractLeft d) 1 = 0
state_after: no goals
Theorem: injective_of_lt_imp_ne
File: Mathlib/Order/Monotone/Basic.lean

tactic: intro x y hf
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
⊢ Injective f
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
⊢ x = y

tactic: rcases lt_trichotomy x y with (hxy | rfl | hxy)
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
⊢ x = y
state_after: case inl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
hxy : x < y
⊢ x = y

case inr.inl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x : α
hf : f x = f x
⊢ x = x

case inr.inr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
hxy : y < x
⊢ x = y

tactic: exact absurd hf <| h _ _ hxy
state_before: case inl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
hxy : x < y
⊢ x = y
state_after: no goals

tactic: rfl
state_before: case inr.inl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x : α
hf : f x = f x
⊢ x = x
state_after: no goals

tactic: exact absurd hf.symm <| h _ _ hxy
state_before: case inr.inr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
hxy : y < x
⊢ x = y
state_after: no goals
Theorem: List.findIdxs_cons
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: dsimp [findIdxs]
state_before: α : Type u_1
x : α
xs : List α
p : α → Bool
⊢ findIdxs p (x :: xs) =
    bif p x then 0 :: map (fun x => x + 1) (findIdxs p xs) else map (fun x => x + 1) (findIdxs p xs)
state_after: α : Type u_1
x : α
xs : List α
p : α → Bool
⊢ (if p x = true then 0 :: foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs 1
    else foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs 1) =
    bif p x then 0 :: map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs)
    else map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs)

tactic: rw [cond_eq_if]
state_before: α : Type u_1
x : α
xs : List α
p : α → Bool
⊢ (if p x = true then 0 :: foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs 1
    else foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs 1) =
    bif p x then 0 :: map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs)
    else map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs)
state_after: α : Type u_1
x : α
xs : List α
p : α → Bool
⊢ (if p x = true then 0 :: foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs 1
    else foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs 1) =
    if p x = true then 0 :: map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs)
    else map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs)

tactic: simp only [Nat.zero_add, foldrIdx_start, Nat.add_zero, cons.injEq, true_and]
state_before: case isFalse
α : Type u_1
x : α
xs : List α
p : α → Bool
h✝ : ¬p x = true
⊢ foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs 1 =
    map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs)
state_after: case isFalse
α : Type u_1
x : α
xs : List α
p : α → Bool
h✝ : ¬p x = true
⊢ foldrIdx (fun i a is => if p a = true then (i + 0 + 1) :: is else is) [] xs =
    map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then (i + 0) :: is else is) [] xs)

tactic: apply findIdxs_cons_aux
state_before: case isFalse
α : Type u_1
x : α
xs : List α
p : α → Bool
h✝ : ¬p x = true
⊢ foldrIdx (fun i a is => if p a = true then (i + 0 + 1) :: is else is) [] xs =
    map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then (i + 0) :: is else is) [] xs)
state_after: no goals