1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: zero_memℓp
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rcases p.trichotomy with (rfl | rfl | hp)
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ Memℓp 0 p
state_after: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ Memℓp 0 0

case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ Memℓp 0 ⊤

case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
⊢ Memℓp 0 p

tactic: apply memℓp_zero
state_before: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ Memℓp 0 0
state_after: case inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ {i | 0 i ≠ 0}.Finite

tactic: simp
state_before: case inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ {i | 0 i ≠ 0}.Finite
state_after: no goals

tactic: apply memℓp_infty
state_before: case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ Memℓp 0 ⊤
state_after: case inr.inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ BddAbove (Set.range fun i => ‖0 i‖)

tactic: simp only [norm_zero, Pi.zero_apply]
state_before: case inr.inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ BddAbove (Set.range fun i => ‖0 i‖)
state_after: case inr.inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ BddAbove (Set.range fun i => 0)

tactic: exact bddAbove_singleton.mono Set.range_const_subset
state_before: case inr.inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ BddAbove (Set.range fun i => 0)
state_after: no goals

tactic: apply memℓp_gen
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
⊢ Memℓp 0 p
state_after: case inr.inr.hf
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
⊢ Summable fun i => ‖0 i‖ ^ p.toReal

tactic: simp [Real.zero_rpow hp.ne', summable_zero]
state_before: case inr.inr.hf
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
⊢ Summable fun i => ‖0 i‖ ^ p.toReal
state_after: no goals
Theorem: norm_jacobiTheta₂_term_le
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

tactic: simp_rw [norm_jacobiTheta₂_term, Real.exp_le_exp, sub_eq_add_neg, neg_mul, ← neg_add,
  neg_le_neg_iff, mul_comm (2 : ℝ), mul_assoc π, ← mul_add, mul_le_mul_left pi_pos,
  mul_comm T, mul_comm S]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ‖jacobiTheta₂_term n z τ‖ ≤ rexp (-π * (T * ↑n ^ 2 - 2 * S * ↑|n|))
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑n ^ 2 * T + -(2 * S * ↑|n|) ≤ ↑n ^ 2 * τ.im + 2 * ↑n * z.im

tactic: refine add_le_add (mul_le_mul le_rfl hτ hT.le (sq_nonneg _)) ?_
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑n ^ 2 * T + -(2 * S * ↑|n|) ≤ ↑n ^ 2 * τ.im + 2 * ↑n * z.im
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ -(2 * S * ↑|n|) ≤ 2 * ↑n * z.im

tactic: rw [← mul_neg, mul_assoc, mul_assoc, mul_le_mul_left two_pos, mul_comm, neg_mul, ← mul_neg]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ -(2 * S * ↑|n|) ≤ 2 * ↑n * z.im
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ ↑n * z.im

tactic: refine le_trans ?_ (neg_abs_le _)
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ ↑n * z.im
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ -|↑n * z.im|

tactic: rw [mul_neg, neg_le_neg_iff, abs_mul, Int.cast_abs]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ↑|n| * -S ≤ -|↑n * z.im|
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ |↑n| * |z.im| ≤ |↑n| * S

tactic: exact mul_le_mul_of_nonneg_left hz (abs_nonneg _)
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ |↑n| * |z.im| ≤ |↑n| * S
state_after: no goals
Theorem: Dual.apply_one_mul_eq
File: Mathlib/LinearAlgebra/Dual.lean

tactic: conv_rhs => rw [← mul_one r, ← smul_eq_mul]
state_before: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : Dual R R
r : R
⊢ f 1 * r = f r
state_after: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : Dual R R
r : R
⊢ f 1 * r = f (r • 1)

tactic: rw [map_smul, smul_eq_mul, mul_comm]
state_before: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : Dual R R
r : R
⊢ f 1 * r = f (r • 1)
state_after: no goals
Theorem: aestronglyMeasurable_union_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simp only [union_eq_iUnion, aestronglyMeasurable_iUnion_iff, Bool.forall_bool, cond, and_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
f g : α → β
inst✝ : PseudoMetrizableSpace β
s t : Set α
⊢ AEStronglyMeasurable f (μ.restrict (s ∪ t)) ↔
    AEStronglyMeasurable f (μ.restrict s) ∧ AEStronglyMeasurable f (μ.restrict t)
state_after: no goals
Theorem: CategoryTheory.Functor.final_iff_isFiltered_structuredArrow
File: Mathlib/CategoryTheory/Filtered/Final.lean

tactic: refine ⟨?_, fun h => final_of_isFiltered_structuredArrow F⟩
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ F.Final ↔ ∀ (d : D), IsFiltered (StructuredArrow d F)
state_after: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ F.Final → ∀ (d : D), IsFiltered (StructuredArrow d F)

tactic: rw [final_iff_of_isFiltered]
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ F.Final → ∀ (d : D), IsFiltered (StructuredArrow d F)
state_after: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ ((∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) ∧
      ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c), ∃ c' t, s ≫ F.map t = s' ≫ F.map t) →
    ∀ (d : D), IsFiltered (StructuredArrow d F)

tactic: exact fun h => isFiltered_structuredArrow_of_isFiltered_of_exists F h.1 h.2
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ ((∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) ∧
      ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c), ∃ c' t, s ≫ F.map t = s' ≫ F.map t) →
    ∀ (d : D), IsFiltered (StructuredArrow d F)
state_after: no goals
Theorem: GromovHausdorff.dist_ghDist
File: Mathlib/Topology/MetricSpace/GromovHausdorff.lean

tactic: rw [ghDist, p.toGHSpace_rep, q.toGHSpace_rep]
state_before: p q : GHSpace
⊢ dist p q = ghDist p.Rep q.Rep
state_after: no goals
Theorem: WittVector.ghostFun_mul
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: ghost_fun_tac X 0 * X 1, ![x.coeff, y.coeff]
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
x y : 𝕎 R
⊢ WittVector.ghostFun (x * y) = WittVector.ghostFun x * WittVector.ghostFun y
state_after: no goals
Theorem: Matrix.UnitaryGroup.toGL_mul
File: Mathlib/LinearAlgebra/UnitaryGroup.lean

tactic: simp only [coe_toGL, toLin'_mul]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ : Matrix n n α
A B : ↥(unitaryGroup n α)
⊢ ↑(toGL (A * B)) = ↑(toGL A * toGL B)
state_after: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ : Matrix n n α
A B : ↥(unitaryGroup n α)
⊢ toLin' A ∘ₗ toLin' B = ↑(toGL A * toGL B)

tactic: rfl
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ : Matrix n n α
A B : ↥(unitaryGroup n α)
⊢ toLin' A ∘ₗ toLin' B = ↑(toGL A * toGL B)
state_after: no goals
Theorem: symmDiff_symmDiff_self'
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, symmDiff_symmDiff_cancel_left]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b ∆ a = b
state_after: no goals
Theorem: Function.minimalPeriod_snd_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [minimalPeriod_prod_map]
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod g x.2 ∣ minimalPeriod (Prod.map f g) x
state_after: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod g x.2 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)

tactic: exact Nat.dvd_lcm_right _ _
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod g x.2 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)
state_after: no goals
Theorem: Set.mem_Ici_Ioi_of_subset_of_subset
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← Ioi_union_left, union_subset_iff]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
s : Set α
ho : Ioi a ⊆ s
hc : s ⊆ Ici a
h : a ∈ s
⊢ Ici a ⊆ s
state_after: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
s : Set α
ho : Ioi a ⊆ s
hc : s ⊆ Ici a
h : a ∈ s
⊢ Ioi a ⊆ s ∧ {a} ⊆ s

tactic: simp [*]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
s : Set α
ho : Ioi a ⊆ s
hc : s ⊆ Ici a
h : a ∈ s
⊢ Ioi a ⊆ s ∧ {a} ⊆ s
state_after: no goals
Theorem: CategoryTheory.Idempotents.Karoubi.comp_proof
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: rw [assoc, comp_p, ← assoc, p_comp]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q R : Karoubi C
g : Q.Hom R
f : P.Hom Q
⊢ f.f ≫ g.f = P.p ≫ (f.f ≫ g.f) ≫ R.p
state_after: no goals
Theorem: UniqueFactorizationMonoid.factors_eq_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: unfold normalizedFactors
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = normalizedFactors x
state_after: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = Multiset.map (⇑normalize) (factors x)

tactic: convert (Multiset.map_id (factors x)).symm
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = Multiset.map (⇑normalize) (factors x)
state_after: case h.e'_3.a.h.e
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
⊢ ⇑normalize = id

tactic: ext p
state_before: case h.e'_3.a.h.e
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
⊢ ⇑normalize = id
state_after: case h.e'_3.a.h.e.h
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
p : M
⊢ normalize p = id p

tactic: exact normalize_eq p
state_before: case h.e'_3.a.h.e.h
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
p : M
⊢ normalize p = id p
state_after: no goals
Theorem: ProbabilityTheory.kernel.iIndepSet_iff_iIndepSets_singleton
File: Mathlib/Probability/Independence/Kernel.lean

tactic: rintro t (rfl : t = _)
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
inst✝ : IsMarkovKernel κ
μ : Measure α
f : ι → Set Ω
hf : ∀ (i : ι), MeasurableSet (f i)
i : ι
⊢ ∀ t ∈ {f i}, MeasurableSet t
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
inst✝ : IsMarkovKernel κ
μ : Measure α
f : ι → Set Ω
hf : ∀ (i : ι), MeasurableSet (f i)
i : ι
⊢ MeasurableSet (f i)

tactic: exact hf _
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
inst✝ : IsMarkovKernel κ
μ : Measure α
f : ι → Set Ω
hf : ∀ (i : ι), MeasurableSet (f i)
i : ι
⊢ MeasurableSet (f i)
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.leftUnshift_units_smul
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

tactic: apply leftUnshift_smul
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
x : Rˣ
⊢ (x • γ).leftUnshift n hn = x • γ.leftUnshift n hn
state_after: no goals
Theorem: Set.IccExtend_range
File: Mathlib/Order/Interval/Set/ProjIcc.lean

tactic: simp only [IccExtend, range_comp f, range_projIcc, image_univ]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x : α
f : ↑(Icc a b) → β
⊢ range (IccExtend h f) = range f
state_after: no goals
Theorem: Multiset.prod_int_mod
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

tactic: induction s using Multiset.induction <;> simp [Int.mul_emod, *]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Multiset ℤ
n : ℤ
⊢ s.prod % n = (map (fun x => x % n) s).prod % n
state_after: no goals
Theorem: ThreeGPFree.image'
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

tactic: rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩ _ ⟨c, hc, rfl⟩ habc
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
s A : Set α
t B : Set β
f✝ : α → β
a : α
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
f : F
hf : InjOn (⇑f) (s * s)
h : ThreeGPFree s
⊢ ThreeGPFree (⇑f '' s)
state_after: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
s A : Set α
t B : Set β
f✝ : α → β
a✝ : α
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
f : F
hf : InjOn (⇑f) (s * s)
h : ThreeGPFree s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
habc : f a * f c = f b * f b
⊢ f a = f b

tactic: rw [h ha hb hc (hf (mul_mem_mul ha hc) (mul_mem_mul hb hb) <| by rwa [map_mul, map_mul])]
state_before: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
s A : Set α
t B : Set β
f✝ : α → β
a✝ : α
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
f : F
hf : InjOn (⇑f) (s * s)
h : ThreeGPFree s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
habc : f a * f c = f b * f b
⊢ f a = f b
state_after: no goals

tactic: rwa [map_mul, map_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
s A : Set α
t B : Set β
f✝ : α → β
a✝ : α
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
f : F
hf : InjOn (⇑f) (s * s)
h : ThreeGPFree s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
habc : f a * f c = f b * f b
⊢ f (a * c) = f (b * b)
state_after: no goals
Theorem: Nat.Primrec'.comp'
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: n m : ℕ
f : Vector ℕ m → ℕ
g : Vector ℕ n → Vector ℕ m
hf : Primrec' f
hg : Vec g
v : Vector ℕ n
⊢ f (ofFn fun i => (g v).get i) = f (g v)
state_after: no goals
Theorem: CategoryTheory.Limits.pullbackSymmetry_hom_comp_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [pullbackSymmetry]
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).hom ≫ pullback.snd = pullback.fst
state_after: no goals
Theorem: InnerProductGeometry.norm_add_eq_norm_sub_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [← sq_eq_sq (norm_nonneg (x + y)) (norm_nonneg (x - y)),
  ← inner_eq_zero_iff_angle_eq_pi_div_two x y, norm_add_pow_two_real, norm_sub_pow_two_real]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ ‖x + y‖ = ‖x - y‖ ↔ angle x y = π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ ‖x‖ ^ 2 + 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2 = ‖x‖ ^ 2 - 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2 ↔ ⟪x, y⟫_ℝ = 0

tactic: constructor <;> intro h <;> linarith
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ ‖x‖ ^ 2 + 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2 = ‖x‖ ^ 2 - 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2 ↔ ⟪x, y⟫_ℝ = 0
state_after: no goals
Theorem: Mathlib.Meta.NormNum.Finset.sum_empty
File: Mathlib/Tactic/NormNum/BigOperators.lean

tactic: simp
state_before: β : Type u_1
α : Type u_2
inst✝ : CommSemiring β
f : α → β
⊢ ∅.sum f = ↑0
state_after: no goals
Theorem: List.getElem?_zip_with
File: Mathlib/Data/List/Zip.lean

tactic: induction' l₁ with head tail generalizing l₂ i
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l₁ : List α
l₂ : List β
i : ℕ
⊢ (zipWith f l₁ l₂)[i]? = (Option.map f l₁[i]?).bind fun g => Option.map g l₂[i]?
state_after: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l₂ : List β
i : ℕ
⊢ (zipWith f [] l₂)[i]? = (Option.map f [][i]?).bind fun g => Option.map g l₂[i]?

case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
head : α
tail : List α
tail_ih✝ : ∀ (l₂ : List β) (i : ℕ), (zipWith f tail l₂)[i]? = (Option.map f tail[i]?).bind fun g => Option.map g l₂[i]?
l₂ : List β
i : ℕ
⊢ (zipWith f (head :: tail) l₂)[i]? = (Option.map f (head :: tail)[i]?).bind fun g => Option.map g l₂[i]?

tactic: rw [zipWith] <;> simp
state_before: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l₂ : List β
i : ℕ
⊢ (zipWith f [] l₂)[i]? = (Option.map f [][i]?).bind fun g => Option.map g l₂[i]?
state_after: no goals

tactic: cases l₂
state_before: case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
head : α
tail : List α
tail_ih✝ : ∀ (l₂ : List β) (i : ℕ), (zipWith f tail l₂)[i]? = (Option.map f tail[i]?).bind fun g => Option.map g l₂[i]?
l₂ : List β
i : ℕ
⊢ (zipWith f (head :: tail) l₂)[i]? = (Option.map f (head :: tail)[i]?).bind fun g => Option.map g l₂[i]?
state_after: case cons.nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
head : α
tail : List α
tail_ih✝ : ∀ (l₂ : List β) (i : ℕ), (zipWith f tail l₂)[i]? = (Option.map f tail[i]?).bind fun g => Option.map g l₂[i]?
i : ℕ
⊢ (zipWith f (head :: tail) [])[i]? = (Option.map f (head :: tail)[i]?).bind fun g => Option.map g [][i]?

case cons.cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
head : α
tail : List α
tail_ih✝ : ∀ (l₂ : List β) (i : ℕ), (zipWith f tail l₂)[i]? = (Option.map f tail[i]?).bind fun g => Option.map g l₂[i]?
i : ℕ
head✝ : β
tail✝ : List β
⊢ (zipWith f (head :: tail) (head✝ :: tail✝))[i]? =
    (Option.map f (head :: tail)[i]?).bind fun g => Option.map g (head✝ :: tail✝)[i]?

tactic: simp
state_before: case cons.nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
head : α
tail : List α
tail_ih✝ : ∀ (l₂ : List β) (i : ℕ), (zipWith f tail l₂)[i]? = (Option.map f tail[i]?).bind fun g => Option.map g l₂[i]?
i : ℕ
⊢ (zipWith f (head :: tail) [])[i]? = (Option.map f (head :: tail)[i]?).bind fun g => Option.map g [][i]?
state_after: no goals

tactic: cases i <;> simp_all
state_before: case cons.cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
head : α
tail : List α
tail_ih✝ : ∀ (l₂ : List β) (i : ℕ), (zipWith f tail l₂)[i]? = (Option.map f tail[i]?).bind fun g => Option.map g l₂[i]?
i : ℕ
head✝ : β
tail✝ : List β
⊢ (zipWith f (head :: tail) (head✝ :: tail✝))[i]? =
    (Option.map f (head :: tail)[i]?).bind fun g => Option.map g (head✝ :: tail✝)[i]?
state_after: no goals