1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LinearLocallyFiniteOrder.le_succFn
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [le_isGLB_iff (succFn_spec i), mem_lowerBounds]
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ i ≤ succFn i
state_after: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ ∀ x ∈ Set.Ioi i, i ≤ x

tactic: exact fun x hx ↦ le_of_lt hx
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ ∀ x ∈ Set.Ioi i, i ≤ x
state_after: no goals
Theorem: Nat.bit1_eq_one
File: Mathlib/Data/Nat/Bits.lean

tactic: subst h
state_before: m n✝ n : ℕ
h : n = 0
⊢ bit1 n = 1
state_after: m n : ℕ
⊢ bit1 0 = 1

tactic: rfl
state_before: m n : ℕ
⊢ bit1 0 = 1
state_after: no goals
Theorem: Besicovitch.SatelliteConfig.centerAndRescale_center
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

tactic: simp [SatelliteConfig.centerAndRescale]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
N : ℕ
τ : ℝ
a : SatelliteConfig E N τ
⊢ a.centerAndRescale.c (last N) = 0
state_after: no goals
Theorem: CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono
File: Mathlib/CategoryTheory/Abelian/DiagramLemmas/Four.lean

tactic: simpa only [R₁.map'_comp 0 1 2] using hR₁.toIsComplex.zero 0
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
R₁ R₂ : ComposableArrows C 3
φ : R₁ ⟶ R₂
hR₁ : R₁.Exact
hR₂ : R₂.Exact
h₀ : Epi (app' φ 0 ⋯)
h₁ : Mono (app' φ 1 ⋯)
h₃ : Mono (app' φ 3 ⋯)
⊢ R₁.map' 0 2 ⋯ ⋯ = 0
state_after: no goals
Theorem: map_finset_inf
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [inf_cons, inf_cons, map_inf, h, Function.comp_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁵ : SemilatticeInf α
inst✝⁴ : OrderTop α
s✝¹ s₁ s₂ : Finset β
f✝ g✝ : β → α
a : α
inst✝³ : SemilatticeInf β
inst✝² : OrderTop β
inst✝¹ : FunLike F α β
inst✝ : InfTopHomClass F α β
f : F
s✝ : Finset ι
g : ι → α
i : ι
s : Finset ι
x✝ : i ∉ s
h : f (s.inf g) = s.inf (⇑f ∘ g)
⊢ f ((cons i s x✝).inf g) = (cons i s x✝).inf (⇑f ∘ g)
state_after: no goals
Theorem: WeierstrassCurve.Affine.CoordinateRing.map_mk
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

tactic: rw [map, AdjoinRoot.lift_mk, ← eval₂_map]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X][Y]
⊢ (map W f) ((mk W) x) = (mk (WeierstrassCurve.map W f)) (Polynomial.map (mapRingHom f) x)
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X][Y]
⊢ eval₂ (AdjoinRoot.of (WeierstrassCurve.map W f).toAffine.polynomial)
      (AdjoinRoot.root (WeierstrassCurve.map W f).toAffine.polynomial) (Polynomial.map (mapRingHom f) x) =
    (mk (WeierstrassCurve.map W f)) (Polynomial.map (mapRingHom f) x)

tactic: exact AdjoinRoot.aeval_eq <| x.map <| mapRingHom f
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X][Y]
⊢ eval₂ (AdjoinRoot.of (WeierstrassCurve.map W f).toAffine.polynomial)
      (AdjoinRoot.root (WeierstrassCurve.map W f).toAffine.polynomial) (Polynomial.map (mapRingHom f) x) =
    (mk (WeierstrassCurve.map W f)) (Polynomial.map (mapRingHom f) x)
state_after: no goals
Theorem: HurwitzZeta.evenKernel_def
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

tactic: unfold evenKernel
state_before: a x : ℝ
⊢ ↑(evenKernel (↑a) x) = cexp (-↑π * ↑a ^ 2 * ↑x) * jacobiTheta₂ (↑a * I * ↑x) (I * ↑x)
state_after: a x : ℝ
⊢ ↑(⋯.lift ↑a) = cexp (-↑π * ↑a ^ 2 * ↑x) * jacobiTheta₂ (↑a * I * ↑x) (I * ↑x)

tactic: simp only [neg_mul, Function.Periodic.lift_coe, ofReal_mul, ofReal_exp, ofReal_neg, ofReal_pow,
  re_eq_add_conj, jacobiTheta₂_conj, map_mul, conj_ofReal, conj_I, mul_neg, neg_neg,
  jacobiTheta₂_neg_left, ← mul_two, mul_div_cancel_right₀ _ (two_ne_zero' ℂ)]
state_before: a x : ℝ
⊢ ↑(⋯.lift ↑a) = cexp (-↑π * ↑a ^ 2 * ↑x) * jacobiTheta₂ (↑a * I * ↑x) (I * ↑x)
state_after: no goals
Theorem: orderOf_map_dvd
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: apply orderOf_dvd_of_pow_eq_one
state_before: G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
H : Type u_6
inst✝ : Monoid H
ψ : G →* H
x : G
⊢ orderOf (ψ x) ∣ orderOf x
state_after: case h
G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
H : Type u_6
inst✝ : Monoid H
ψ : G →* H
x : G
⊢ ψ x ^ orderOf x = 1

tactic: rw [← map_pow, pow_orderOf_eq_one]
state_before: case h
G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
H : Type u_6
inst✝ : Monoid H
ψ : G →* H
x : G
⊢ ψ x ^ orderOf x = 1
state_after: case h
G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
H : Type u_6
inst✝ : Monoid H
ψ : G →* H
x : G
⊢ ψ 1 = 1

tactic: apply map_one
state_before: case h
G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
H : Type u_6
inst✝ : Monoid H
ψ : G →* H
x : G
⊢ ψ 1 = 1
state_after: no goals
Theorem: LieAlgebra.self_module_ker_eq_center
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: ext y
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
⊢ LieModule.ker R L L = center R L
state_after: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
y : L
⊢ y ∈ LieModule.ker R L L ↔ y ∈ center R L

tactic: simp only [LieModule.mem_maxTrivSubmodule, LieModule.mem_ker, ← lie_skew _ y, neg_eq_zero]
state_before: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
y : L
⊢ y ∈ LieModule.ker R L L ↔ y ∈ center R L
state_after: no goals
Theorem: edist_le_coe
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [edist_nndist, ENNReal.coe_le_coe]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : α
c : ℝ≥0
⊢ edist x y ≤ ↑c ↔ nndist x y ≤ c
state_after: no goals
Theorem: ENNReal.ofReal_mul
File: Mathlib/Data/ENNReal/Real.lean

tactic: simp only [ENNReal.ofReal, ← coe_mul, Real.toNNReal_mul hp]
state_before: a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hp : 0 ≤ p
⊢ ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q
state_after: no goals
Theorem: Set.pi_update_of_not_mem
File: Mathlib/Data/Set/Prod.lean

tactic: rw [update_noteq]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
hi : i ∉ s
f : (j : ι) → α j
a : α i
t : (j : ι) → α j → Set (β j)
j : ι
hj : j ∈ s
⊢ t j (update f i a j) = t j (f j)
state_after: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
hi : i ∉ s
f : (j : ι) → α j
a : α i
t : (j : ι) → α j → Set (β j)
j : ι
hj : j ∈ s
⊢ j ≠ i

tactic: exact fun h => hi (h ▸ hj)
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
hi : i ∉ s
f : (j : ι) → α j
a : α i
t : (j : ι) → α j → Set (β j)
j : ι
hj : j ∈ s
⊢ j ≠ i
state_after: no goals
Theorem: MeasureTheory.AEStronglyMeasurable'.continuous_comp
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean

tactic: rw [Function.comp_apply, hx]
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝¹ : TopologicalSpace β
f✝ g✝ : α → β
γ : Type u_4
inst✝ : TopologicalSpace γ
f : α → β
g : β → γ
hg : Continuous g
hf : AEStronglyMeasurable' m f μ
x : α
hx : f x = mk f hf x
⊢ (g ∘ f) x = (fun x => g (mk f hf x)) x
state_after: no goals
Theorem: abs_sub_le_of_nonneg_of_le
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [abs_sub_le_iff, sub_le_iff_le_add, sub_le_iff_le_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_le_n : a ≤ n
b_nonneg : 0 ≤ b
b_le_n : b ≤ n
⊢ |a - b| ≤ n
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_le_n : a ≤ n
b_nonneg : 0 ≤ b
b_le_n : b ≤ n
⊢ a ≤ n + b ∧ b ≤ n + a

tactic: exact ⟨le_add_of_le_of_nonneg a_le_n b_nonneg, le_add_of_le_of_nonneg b_le_n a_nonneg⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_le_n : a ≤ n
b_nonneg : 0 ≤ b
b_le_n : b ≤ n
⊢ a ≤ n + b ∧ b ≤ n + a
state_after: no goals
Theorem: Nat.eq_of_perm_factors
File: Mathlib/Data/Nat/Factors.lean

tactic: simpa [prod_factors ha, prod_factors hb] using List.Perm.prod_eq h
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
h : a.factors ~ b.factors
⊢ a = b
state_after: no goals
Theorem: Path.Homotopy.transAssocReparamAux_zero
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: norm_num [transAssocReparamAux]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ transAssocReparamAux 0 = 0
state_after: no goals
Theorem: Real.sinh_two_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ sinh (2 * x) = 2 * sinh x * cosh x
state_after: x y : ℝ
⊢ ↑(sinh (2 * x)) = ↑(2 * sinh x * cosh x)

tactic: simp [sinh_two_mul]
state_before: x y : ℝ
⊢ ↑(sinh (2 * x)) = ↑(2 * sinh x * cosh x)
state_after: no goals
Theorem: Associates.mk_pow
File: Mathlib/Algebra/Associated.lean

tactic: induction n <;> simp [*, pow_succ, Associates.mk_mul_mk.symm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a : α
n : ℕ
⊢ Associates.mk (a ^ n) = Associates.mk a ^ n
state_after: no goals
Theorem: Turing.PartrecToTM2.trStmts₁_self
File: Mathlib/Computability/TMToPartrec.lean

tactic: first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
state_before: case ret
k✝ : Cont'
⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)
state_after: no goals

tactic: apply Finset.mem_singleton_self
state_before: case ret
k✝ : Cont'
⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)
state_after: no goals

tactic: apply Finset.mem_insert_self
state_before: case pred
q₁✝ q₂✝ : Λ'
q₁_ih✝ : q₁✝ ∈ trStmts₁ q₁✝
q₂_ih✝ : q₂✝ ∈ trStmts₁ q₂✝
⊢ q₁✝.pred q₂✝ ∈ trStmts₁ (q₁✝.pred q₂✝)
state_after: no goals
Theorem: int_prod_range_pos
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: refine (int_prod_range_nonneg m n hn).lt_of_ne fun h => hm ?_
state_before: m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
⊢ 0 < ∏ k ∈ Finset.range n, (m - ↑k)
state_after: m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
h : 0 = ∏ k ∈ Finset.range n, (m - ↑k)
⊢ m ∈ Ico 0 ↑n

tactic: rw [eq_comm, Finset.prod_eq_zero_iff] at h
state_before: m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
h : 0 = ∏ k ∈ Finset.range n, (m - ↑k)
⊢ m ∈ Ico 0 ↑n
state_after: m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
h : ∃ a ∈ Finset.range n, m - ↑a = 0
⊢ m ∈ Ico 0 ↑n

tactic: obtain ⟨a, ha, h⟩ := h
state_before: m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
h : ∃ a ∈ Finset.range n, m - ↑a = 0
⊢ m ∈ Ico 0 ↑n
state_after: case intro.intro
m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
a : ℕ
ha : a ∈ Finset.range n
h : m - ↑a = 0
⊢ m ∈ Ico 0 ↑n

tactic: rw [sub_eq_zero.1 h]
state_before: case intro.intro
m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
a : ℕ
ha : a ∈ Finset.range n
h : m - ↑a = 0
⊢ m ∈ Ico 0 ↑n
state_after: case intro.intro
m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
a : ℕ
ha : a ∈ Finset.range n
h : m - ↑a = 0
⊢ ↑a ∈ Ico 0 ↑n

tactic: exact ⟨Int.ofNat_zero_le _, Int.ofNat_lt.2 <| Finset.mem_range.1 ha⟩
state_before: case intro.intro
m : ℤ
n : ℕ
hn : Even n
hm : m ∉ Ico 0 ↑n
a : ℕ
ha : a ∈ Finset.range n
h : m - ↑a = 0
⊢ ↑a ∈ Ico 0 ↑n
state_after: no goals
Theorem: Ordinal.toPGame_equiv_iff
File: Mathlib/SetTheory/Game/Ordinal.lean

tactic: change _ ≤_ ∧ _ ≤ _ ↔ _
state_before: a b : Ordinal.{u_1}
⊢ a.toPGame ≈ b.toPGame ↔ a = b
state_after: a b : Ordinal.{u_1}
⊢ a.toPGame ≤ b.toPGame ∧ b.toPGame ≤ a.toPGame ↔ a = b

tactic: rw [le_antisymm_iff, toPGame_le_iff, toPGame_le_iff]
state_before: a b : Ordinal.{u_1}
⊢ a.toPGame ≤ b.toPGame ∧ b.toPGame ≤ a.toPGame ↔ a = b
state_after: no goals
Theorem: Vector.continuousAt_eraseIdx
File: Mathlib/Topology/List.lean

tactic: rw [ContinuousAt, eraseIdx, tendsto_subtype_rng]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : l.length = n + 1
⊢ ContinuousAt (eraseIdx i) ⟨l, hl⟩
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : l.length = n + 1
⊢ Tendsto (fun x => ↑(eraseIdx i x)) (𝓝 ⟨l, hl⟩)
    (𝓝
      ↑(match ⟨l, hl⟩ with
        | ⟨l, p⟩ => ⟨l.eraseIdx ↑i, ⋯⟩))

tactic: simp only [Vector.eraseIdx_val]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : l.length = n + 1
⊢ Tendsto (fun x => ↑(eraseIdx i x)) (𝓝 ⟨l, hl⟩)
    (𝓝
      ↑(match ⟨l, hl⟩ with
        | ⟨l, p⟩ => ⟨l.eraseIdx ↑i, ⋯⟩))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : l.length = n + 1
⊢ Tendsto (fun x => (↑x).eraseIdx ↑i) (𝓝 ⟨l, hl⟩) (𝓝 (l.eraseIdx ↑i))

tactic: exact Tendsto.comp List.tendsto_eraseIdx continuousAt_subtype_val
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : l.length = n + 1
⊢ Tendsto (fun x => (↑x).eraseIdx ↑i) (𝓝 ⟨l, hl⟩) (𝓝 (l.eraseIdx ↑i))
state_after: no goals
Theorem: List.prod_eq_one_iff
File: Mathlib/Algebra/Order/BigOperators/Group/List.lean

tactic: rw [List.eq_replicate.2 ⟨_, h⟩, prod_replicate, one_pow]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ l.prod = 1
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ ℕ

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ l.length = ?m.22387

tactic: exact (length l)
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ ℕ
state_after: no goals

tactic: rfl
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ l.length = l.length
state_after: no goals
Theorem: LinearOrderedField.cutMap_coe
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: simp_rw [cutMap, Rat.cast_lt]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : LinearOrderedField β
a a₁ a₂ : α
b : β
q✝ q : ℚ
⊢ cutMap β ↑q = Rat.cast '' {r | ↑r < ↑q}
state_after: no goals
Theorem: dist_lineMap_right
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: simpa only [lineMap_apply_one, dist_eq_norm'] using dist_lineMap_lineMap p₁ p₂ c 1
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist ((lineMap p₁ p₂) c) p₂ = ‖1 - c‖ * dist p₁ p₂
state_after: no goals
Theorem: Filter.mem_biInf_of_directed
File: Mathlib/Order/Filter/Basic.lean

tactic: haveI := ne.to_subtype
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : β → Filter α
s : Set β
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s
ne : s.Nonempty
t : Set α
⊢ t ∈ ⨅ i ∈ s, f i ↔ ∃ i ∈ s, t ∈ f i
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : β → Filter α
s : Set β
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s
ne : s.Nonempty
t : Set α
this : Nonempty ↑s
⊢ t ∈ ⨅ i ∈ s, f i ↔ ∃ i ∈ s, t ∈ f i

tactic: simp_rw [iInf_subtype', mem_iInf_of_directed h.directed_val, Subtype.exists, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : β → Filter α
s : Set β
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s
ne : s.Nonempty
t : Set α
this : Nonempty ↑s
⊢ t ∈ ⨅ i ∈ s, f i ↔ ∃ i ∈ s, t ∈ f i
state_after: no goals
Theorem: Multiset.sub_le_iff_le_add
File: Mathlib/Data/Multiset/Basic.lean

tactic: revert s
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
⊢ s - t ≤ u ↔ s ≤ u + t
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
t u : Multiset α
a b : α
⊢ ∀ {s : Multiset α}, s - t ≤ u ↔ s ≤ u + t

tactic: exact @(Multiset.induction_on t (by simp [Multiset.sub_zero]) fun a t IH s => by
    simp [IH, erase_le_iff_le_cons])
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
t u : Multiset α
a b : α
⊢ ∀ {s : Multiset α}, s - t ≤ u ↔ s ≤ u + t
state_after: no goals

tactic: simp [Multiset.sub_zero]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
t u : Multiset α
a b : α
⊢ ∀ {s : Multiset α}, s - 0 ≤ u ↔ s ≤ u + 0
state_after: no goals

tactic: simp [IH, erase_le_iff_le_cons]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
t✝ u : Multiset α
a✝ b a : α
t : Multiset α
IH : ∀ {s : Multiset α}, s - t ≤ u ↔ s ≤ u + t
s : Multiset α
⊢ s - a ::ₘ t ≤ u ↔ s ≤ u + a ::ₘ t
state_after: no goals
Theorem: gaussSum_eq_zero_of_isPrimitive_of_not_isPrimitive
File: Mathlib/NumberTheory/DirichletCharacter/GaussSum.lean

tactic: contrapose! hχ
state_before: N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
hχ : χ.IsPrimitive
he : ¬e.IsPrimitive
⊢ gaussSum χ e = 0
state_after: N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
⊢ ¬χ.IsPrimitive

tactic: rcases e.exists_divisor_of_not_isPrimitive he with ⟨d, hd₁, hd₂, hed⟩
state_before: N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
⊢ ¬χ.IsPrimitive
state_after: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
⊢ ¬χ.IsPrimitive

tactic: have : χ.conductor ≤ d := Nat.sInf_le <| factorsThrough_of_gaussSum_ne_zero e hd₁ hed hχ
state_before: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
⊢ ¬χ.IsPrimitive
state_after: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
this : χ.conductor ≤ d
⊢ ¬χ.IsPrimitive

tactic: exact (this.trans_lt hd₂).ne
state_before: case intro.intro.intro
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
he : ¬e.IsPrimitive
hχ : gaussSum χ e ≠ 0
d : ℕ
hd₁ : d ∣ N
hd₂ : d < N
hed : e.mulShift ↑d = 1
this : χ.conductor ≤ d
⊢ ¬χ.IsPrimitive
state_after: no goals
Theorem: Equiv.conj_comp
File: Mathlib/Logic/Equiv/Defs.lean

tactic: apply arrowCongr_comp
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
f₁ f₂ : α → α
⊢ e.conj (f₁ ∘ f₂) = e.conj f₁ ∘ e.conj f₂
state_after: no goals
Theorem: Nat.snd_mem_divisors_of_mem_antidiagonal
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [mem_divisorsAntidiagonal] at h
state_before: n : ℕ
x : ℕ × ℕ
h : x ∈ n.divisorsAntidiagonal
⊢ x.2 ∈ n.divisors
state_after: n : ℕ
x : ℕ × ℕ
h : x.1 * x.2 = n ∧ n ≠ 0
⊢ x.2 ∈ n.divisors

tactic: simp [Dvd.intro_left _ h.1, h.2]
state_before: n : ℕ
x : ℕ × ℕ
h : x.1 * x.2 = n ∧ n ≠ 0
⊢ x.2 ∈ n.divisors
state_after: no goals
Theorem: div_mul_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b * c = c / b * a
state_after: no goals
Theorem: AddCircle.norm_div_natCast
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: have : p⁻¹ * (↑m / ↑n * p) = ↑m / ↑n := by rw [mul_comm _ p, inv_mul_cancel_left₀ hp.out.ne.symm]
state_before: p : ℝ
hp : Fact (0 < p)
m n : ℕ
⊢ ‖↑(↑m / ↑n * p)‖ = p * (↑(min (m % n) (n - m % n)) / ↑n)
state_after: p : ℝ
hp : Fact (0 < p)
m n : ℕ
this : p⁻¹ * (↑m / ↑n * p) = ↑m / ↑n
⊢ ‖↑(↑m / ↑n * p)‖ = p * (↑(min (m % n) (n - m % n)) / ↑n)

tactic: rw [norm_eq' p hp.out, this, abs_sub_round_div_natCast_eq]
state_before: p : ℝ
hp : Fact (0 < p)
m n : ℕ
this : p⁻¹ * (↑m / ↑n * p) = ↑m / ↑n
⊢ ‖↑(↑m / ↑n * p)‖ = p * (↑(min (m % n) (n - m % n)) / ↑n)
state_after: no goals

tactic: rw [mul_comm _ p, inv_mul_cancel_left₀ hp.out.ne.symm]
state_before: p : ℝ
hp : Fact (0 < p)
m n : ℕ
⊢ p⁻¹ * (↑m / ↑n * p) = ↑m / ↑n
state_after: no goals
Theorem: Polynomial.exists_eval_ne_zero_of_natDegree_lt_card
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: contrapose! hf
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q f : R[X]
hf : f ≠ 0
hfR : ↑f.natDegree < #R
⊢ ∃ r, eval r f ≠ 0
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q f : R[X]
hfR : ↑f.natDegree < #R
hf : ∀ (r : R), eval r f = 0
⊢ f = 0

tactic: exact eq_zero_of_forall_eval_zero_of_natDegree_lt_card f hf hfR
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q f : R[X]
hfR : ↑f.natDegree < #R
hf : ∀ (r : R), eval r f = 0
⊢ f = 0
state_after: no goals
Theorem: mulLECancellable_one
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

tactic: simpa only [one_mul] using id
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : LE α
a b : α
⊢ 1 * a ≤ 1 * b → a ≤ b
state_after: no goals
Theorem: List.forall₂_same
File: Mathlib/Data/List/Forall2.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ Forall₂ Rₐ [] [] ↔ ∀ (x : α), x ∈ [] → Rₐ x x
state_after: no goals

tactic: simp [@forall₂_same l]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a : α
l : List α
⊢ Forall₂ Rₐ (a :: l) (a :: l) ↔ ∀ (x : α), x ∈ a :: l → Rₐ x x
state_after: no goals