1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Fin.append_left_nil
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [hu, Nat.zero_add]
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
⊢ m + n = n
state_after: no goals

tactic: refine funext (Fin.addCases (fun l => ?_) fun r => ?_)
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
⊢ append u v = v ∘ cast ⋯
state_after: case refine_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
l : Fin m
⊢ append u v (castAdd n l) = (v ∘ cast ⋯) (castAdd n l)

case refine_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
r : Fin n
⊢ append u v (natAdd m r) = (v ∘ cast ⋯) (natAdd m r)

tactic: exact (Fin.cast hu l).elim0
state_before: case refine_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
l : Fin m
⊢ append u v (castAdd n l) = (v ∘ cast ⋯) (castAdd n l)
state_after: no goals

tactic: rw [append_right, Function.comp_apply]
state_before: case refine_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
r : Fin n
⊢ append u v (natAdd m r) = (v ∘ cast ⋯) (natAdd m r)
state_after: case refine_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
r : Fin n
⊢ v r = v (cast ⋯ (natAdd m r))

tactic: refine congr_arg v (Fin.ext ?_)
state_before: case refine_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
r : Fin n
⊢ v r = v (cast ⋯ (natAdd m r))
state_after: case refine_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
r : Fin n
⊢ ↑r = ↑(cast ⋯ (natAdd m r))

tactic: simp [hu]
state_before: case refine_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
r : Fin n
⊢ ↑r = ↑(cast ⋯ (natAdd m r))
state_after: no goals
Theorem: CategoryTheory.IsHomLift.commSq
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

tactic: simp only [fac p f φ, eqToHom_trans_assoc, eqToHom_refl, id_comp]
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₂} 𝒳
inst✝¹ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
inst✝ : p.IsHomLift f φ
⊢ p.map φ ≫ eqToHom ⋯ = eqToHom ⋯ ≫ f
state_after: no goals
Theorem: WittVector.mapFun.one
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
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
⊢ mapFun (⇑f) 1 = 1
state_after: no goals
Theorem: Polynomial.opRingEquiv_symm_C_mul_X_pow
File: Mathlib/RingTheory/Polynomial/Opposites.lean

tactic: rw [C_mul_X_pow_eq_monomial, opRingEquiv_symm_monomial, C_mul_X_pow_eq_monomial]
state_before: R : Type u_1
inst✝ : Semiring R
r : Rᵐᵒᵖ
n : ℕ
⊢ (opRingEquiv R).symm (C r * X ^ n) = op (C (unop r) * X ^ n)
state_after: no goals
Theorem: HomologicalComplex₂.d₁_eq_zero
File: Mathlib/Algebra/Homology/TotalComplex.lean

tactic: dsimp [d₁]
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : ¬c₁.Rel i₁ (c₁.next i₁)
⊢ K.d₁ c₁₂ i₁ i₂ i₁₂ = 0
state_after: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : ¬c₁.Rel i₁ (c₁.next i₁)
⊢ c₁.ε₁ c₂ c₁₂ (i₁, i₂) •
      (K.d i₁ (c₁.next i₁)).f i₂ ≫ K.toGradedObject.ιMapObjOrZero (c₁.π c₂ c₁₂) (c₁.next i₁, i₂) i₁₂ =
    0

tactic: rw [K.shape_f _ _ h, zero_comp, smul_zero]
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : ¬c₁.Rel i₁ (c₁.next i₁)
⊢ c₁.ε₁ c₂ c₁₂ (i₁, i₂) •
      (K.d i₁ (c₁.next i₁)).f i₂ ≫ K.toGradedObject.ιMapObjOrZero (c₁.π c₂ c₁₂) (c₁.next i₁, i₂) i₁₂ =
    0
state_after: no goals
Theorem: MulChar.isNontrivial_iff
File: Mathlib/NumberTheory/MulChar/Basic.lean

tactic: simp only [IsNontrivial, Ne, ext_iff, not_forall, one_apply_coe]
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
⊢ χ.IsNontrivial ↔ χ ≠ 1
state_after: no goals
Theorem: toIocMod_add_left'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIocMod_add_right', add_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (p + a) b = p + toIocMod hp a b
state_after: no goals
Theorem: Cardinal.not_injective_limitation_set
File: Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean

tactic: intro h_inj
state_before: α : Type u
g : Ordinal.{u} → α
⊢ ¬InjOn g (Iio (succ #α).ord)
state_after: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
⊢ False

tactic: have h := lift_mk_le_lift_mk_of_injective <| injOn_iff_injective.1 h_inj
state_before: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
⊢ False
state_after: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
h : lift.{u, u + 1} #↑(Iio (succ #α).ord) ≤ lift.{u + 1, u} #α
⊢ False

tactic: have mk_initialSeg_subtype :
    #(Iio (ord <| succ #α)) = lift.{u + 1} (succ #α) := by
  simpa only [coe_setOf, card_typein, card_ord] using mk_initialSeg (ord <| succ #α)
state_before: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
h : lift.{u, u + 1} #↑(Iio (succ #α).ord) ≤ lift.{u + 1, u} #α
⊢ False
state_after: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
h : lift.{u, u + 1} #↑(Iio (succ #α).ord) ≤ lift.{u + 1, u} #α
mk_initialSeg_subtype : #↑(Iio (succ #α).ord) = lift.{u + 1, u} (succ #α)
⊢ False

tactic: rw [mk_initialSeg_subtype, lift_lift, lift_le] at h
state_before: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
h : lift.{u, u + 1} #↑(Iio (succ #α).ord) ≤ lift.{u + 1, u} #α
mk_initialSeg_subtype : #↑(Iio (succ #α).ord) = lift.{u + 1, u} (succ #α)
⊢ False
state_after: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
h : succ #α ≤ #α
mk_initialSeg_subtype : #↑(Iio (succ #α).ord) = lift.{u + 1, u} (succ #α)
⊢ False

tactic: exact not_le_of_lt (Order.lt_succ #α) h
state_before: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
h : succ #α ≤ #α
mk_initialSeg_subtype : #↑(Iio (succ #α).ord) = lift.{u + 1, u} (succ #α)
⊢ False
state_after: no goals

tactic: simpa only [coe_setOf, card_typein, card_ord] using mk_initialSeg (ord <| succ #α)
state_before: α : Type u
g : Ordinal.{u} → α
h_inj : InjOn g (Iio (succ #α).ord)
h : lift.{u, u + 1} #↑(Iio (succ #α).ord) ≤ lift.{u + 1, u} #α
⊢ #↑(Iio (succ #α).ord) = lift.{u + 1, u} (succ #α)
state_after: no goals
Theorem: continuousOn_singleton
File: Mathlib/Topology/ContinuousOn.lean

tactic: simpa only [ContinuousWithinAt, nhdsWithin_singleton, tendsto_pure_left] using fun s =>
  mem_of_mem_nhds
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
a : α
⊢ ContinuousWithinAt f {a} a
state_after: no goals
Theorem: ProbabilityTheory.ofReal_condCDF_ae_eq
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

tactic: filter_upwards [condCDF_ae_eq ρ r, preCDF_le_one ρ] with a ha ha_le_one
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
⊢ (fun a => ENNReal.ofReal (↑(condCDF ρ a) ↑r)) =ᶠ[ae ρ.fst] preCDF ρ r
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
a : α
ha : ↑(condCDF ρ a) ↑r = (preCDF ρ r a).toReal
ha_le_one : ∀ (r : ℚ), preCDF ρ r a ≤ 1
⊢ ENNReal.ofReal (↑(condCDF ρ a) ↑r) = preCDF ρ r a

tactic: rw [ha, ENNReal.ofReal_toReal]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
a : α
ha : ↑(condCDF ρ a) ↑r = (preCDF ρ r a).toReal
ha_le_one : ∀ (r : ℚ), preCDF ρ r a ≤ 1
⊢ ENNReal.ofReal (↑(condCDF ρ a) ↑r) = preCDF ρ r a
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
a : α
ha : ↑(condCDF ρ a) ↑r = (preCDF ρ r a).toReal
ha_le_one : ∀ (r : ℚ), preCDF ρ r a ≤ 1
⊢ preCDF ρ r a ≠ ⊤

tactic: exact ((ha_le_one r).trans_lt ENNReal.one_lt_top).ne
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
a : α
ha : ↑(condCDF ρ a) ↑r = (preCDF ρ r a).toReal
ha_le_one : ∀ (r : ℚ), preCDF ρ r a ≤ 1
⊢ preCDF ρ r a ≠ ⊤
state_after: no goals
Theorem: CategoryTheory.IsConnected.of_induct
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: have w := h { j | F j = F j₀ } rfl (fun {j₁} {j₂} f => by
  change F j₁ = F j₀ ↔ F j₂ = F j₀
  simp [a f])
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
⊢ ∀ (j j' : J), F j = F j'
state_after: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
w : ∀ (j : J), j ∈ {j | F j = F j₀}
⊢ ∀ (j j' : J), F j = F j'

tactic: intro j j'
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
w : ∀ (j : J), j ∈ {j | F j = F j₀}
⊢ ∀ (j j' : J), F j = F j'
state_after: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
w : ∀ (j : J), j ∈ {j | F j = F j₀}
j j' : J
⊢ F j = F j'

tactic: rw [w j, w j']
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
w : ∀ (j : J), j ∈ {j | F j = F j₀}
j j' : J
⊢ F j = F j'
state_after: no goals

tactic: change F j₁ = F j₀ ↔ F j₂ = F j₀
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
j₁ j₂ : J
f : j₁ ⟶ j₂
⊢ j₁ ∈ {j | F j = F j₀} ↔ j₂ ∈ {j | F j = F j₀}
state_after: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
j₁ j₂ : J
f : j₁ ⟶ j₂
⊢ F j₁ = F j₀ ↔ F j₂ = F j₀

tactic: simp [a f]
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
j₀ : J
h : ∀ (p : Set J), j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p
this : Nonempty J
α : Type u₁
F : J → α
a : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → F j₁ = F j₂
j₁ j₂ : J
f : j₁ ⟶ j₂
⊢ F j₁ = F j₀ ↔ F j₂ = F j₀
state_after: no goals
Theorem: CategoryTheory.pre_map
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

tactic: rw [pre, pre, pre, transferNatTransSelf_comp, prod.functor.map_comp]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Exponentiable A
A₁ A₂ A₃ : C
inst✝² : Exponentiable A₁
inst✝¹ : Exponentiable A₂
inst✝ : Exponentiable A₃
f : A₁ ⟶ A₂
g : A₂ ⟶ A₃
⊢ pre (f ≫ g) = pre g ≫ pre f
state_after: no goals
Theorem: LinearMap.IsAdjointPair.sub
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: rw [f.sub_apply, g.sub_apply, B'.map_sub₂, (B x).map_sub, h, h']
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M₁
inst✝² : Module R M₁
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
B F : M →ₗ[R] M →ₗ[R] M₂
B' : M₁ →ₗ[R] M₁ →ₗ[R] M₂
f f' : M →ₗ[R] M₁
g g' : M₁ →ₗ[R] M
h : B.IsAdjointPair B' f g
h' : B.IsAdjointPair B' f' g'
x : M
x✝ : M₁
⊢ (B' ((f - f') x)) x✝ = (B x) ((g - g') x✝)
state_after: no goals
Theorem: forall_apply_eq_imp_iff'
File: Mathlib/Logic/Basic.lean

tactic: simp
state_before: α : Sort u_1
β : Sort u_2
p✝ q : α → Prop
f : α → β
p : β → Prop
⊢ (∀ (a : α) (b : β), f a = b → p b) ↔ ∀ (a : α), p (f a)
state_after: no goals
Theorem: mul_le_mul_left₀
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

tactic: simp only [mul_comm a]
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
ha : a ≠ 0
⊢ a * b ≤ a * c ↔ b ≤ c
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
ha : a ≠ 0
⊢ b * a ≤ c * a ↔ b ≤ c

tactic: exact mul_le_mul_right₀ ha
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
ha : a ≠ 0
⊢ b * a ≤ c * a ↔ b ≤ c
state_after: no goals
Theorem: Real.cosh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cosh]
state_before: x y : ℝ
⊢ cosh 0 = 1
state_after: no goals
Theorem: CancelDenoms.cancel_factors_eq_div
File: Mathlib/Tactic/CancelDenoms/Core.lean

tactic: rwa [mul_comm] at h
state_before: α : Type u_1
inst✝ : Field α
n e e' : α
h : n * e = e'
h2 : n ≠ 0
⊢ e * n = e'
state_after: no goals
Theorem: MeasureTheory.pdf.IsUniform.cond
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: unfold IsUniform
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
⊢ IsUniform id s (ProbabilityTheory.cond μ s) μ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
⊢ Measure.map id (ProbabilityTheory.cond μ s) = ProbabilityTheory.cond μ s

tactic: rw [Measure.map_id]
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
⊢ Measure.map id (ProbabilityTheory.cond μ s) = ProbabilityTheory.cond μ s
state_after: no goals
Theorem: ENNReal.top_mul'
File: Mathlib/Data/ENNReal/Operations.lean

tactic: convert WithTop.top_mul' a
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
⊢ ⊤ * a = if a = 0 then 0 else ⊤
state_after: no goals
Theorem: PowerBasis.aeval_minpolyGen
File: Mathlib/RingTheory/PowerBasis.lean

tactic: simp_rw [minpolyGen, AlgHom.map_sub, AlgHom.map_sum, AlgHom.map_mul, AlgHom.map_pow, aeval_C, ←
  Algebra.smul_def, aeval_X]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
⊢ (aeval pb.gen) pb.minpolyGen = 0
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
⊢ pb.gen ^ pb.dim - ∑ x : Fin pb.dim, (pb.basis.repr (pb.gen ^ pb.dim)) x • pb.gen ^ ↑x = 0

tactic: refine sub_eq_zero.mpr ((pb.basis.total_repr (pb.gen ^ pb.dim)).symm.trans ?_)
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
⊢ pb.gen ^ pb.dim - ∑ x : Fin pb.dim, (pb.basis.repr (pb.gen ^ pb.dim)) x • pb.gen ^ ↑x = 0
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
⊢ (Finsupp.total (Fin pb.dim) S A ⇑pb.basis) (pb.basis.repr (pb.gen ^ pb.dim)) =
    ∑ x : Fin pb.dim, (pb.basis.repr (pb.gen ^ pb.dim)) x • pb.gen ^ ↑x

tactic: rw [Finsupp.total_apply, Finsupp.sum_fintype] <;>
  simp only [pb.coe_basis, zero_smul, eq_self_iff_true, imp_true_iff]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_6
inst✝¹ : Field K
inst✝ : Algebra A S
pb : PowerBasis A S
⊢ (Finsupp.total (Fin pb.dim) S A ⇑pb.basis) (pb.basis.repr (pb.gen ^ pb.dim)) =
    ∑ x : Fin pb.dim, (pb.basis.repr (pb.gen ^ pb.dim)) x • pb.gen ^ ↑x
state_after: no goals
Theorem: WittVector.discreteValuationRing
File: Mathlib/RingTheory/WittVector/DiscreteValuationRing.lean

tactic: refine ⟨p, irreducible p, fun {x} hx => ?_⟩
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
⊢ DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization (𝕎 k)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
⊢ ∃ n, Associated (↑p ^ n) x

tactic: obtain ⟨n, b, hb⟩ := exists_eq_pow_p_mul' x hx
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
⊢ ∃ n, Associated (↑p ^ n) x
state_after: case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
n : ℕ
b : (𝕎 k)ˣ
hb : x = ↑p ^ n * ↑b
⊢ ∃ n, Associated (↑p ^ n) x

tactic: exact ⟨n, b, hb.symm⟩
state_before: case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
x : 𝕎 k
hx : x ≠ 0
n : ℕ
b : (𝕎 k)ˣ
hb : x = ↑p ^ n * ↑b
⊢ ∃ n, Associated (↑p ^ n) x
state_after: no goals
Theorem: Polynomial.aeval_endomorphism
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

tactic: rw [aeval_def, eval₂_eq_sum]
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 : ℕ
M : Type u_3
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
p : R[X]
⊢ ((aeval f) p) v = p.sum fun n b => b • (f ^ n) v
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 : ℕ
M : Type u_3
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
p : R[X]
⊢ (p.sum fun e a => (algebraMap R (M →ₗ[R] M)) a * f ^ e) v = p.sum fun n b => b • (f ^ n) v

tactic: exact map_sum (LinearMap.applyₗ v) _ _
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 : ℕ
M : Type u_3
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
p : R[X]
⊢ (p.sum fun e a => (algebraMap R (M →ₗ[R] M)) a * f ^ e) v = p.sum fun n b => b • (f ^ n) v
state_after: no goals
Theorem: norm_midpoint_lt_iff
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: rw [norm_smul, Real.norm_of_nonneg (one_div_nonneg.2 zero_le_two), ← inv_eq_one_div, ←
  div_eq_inv_mul, div_lt_iff (zero_lt_two' ℝ), mul_two, ← not_sameRay_iff_of_norm_eq h,
  not_sameRay_iff_norm_add_lt, h]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : ‖x‖ = ‖y‖
⊢ ‖(1 / 2) • (x + y)‖ < ‖x‖ ↔ x ≠ y
state_after: no goals
Theorem: Set.Iic_diff_Iio_same
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← Iic_diff_right, diff_diff_cancel_left (singleton_subset_iff.2 right_mem_Iic)]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
⊢ Iic a \ Iio a = {a}
state_after: no goals
Theorem: InnerProductGeometry.cos_angle_mul_norm_mul_norm
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [cos_angle, div_mul_cancel_of_imp]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ cos (angle x y) * (‖x‖ * ‖y‖) = ⟪x, y⟫_ℝ
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ ‖x‖ * ‖y‖ = 0 → ⟪x, y⟫_ℝ = 0

tactic: simp (config := { contextual := true }) [or_imp]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ ‖x‖ * ‖y‖ = 0 → ⟪x, y⟫_ℝ = 0
state_after: no goals