1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.ker_mulVecLin_conjTranspose_mul_self
File: Mathlib/Data/Matrix/Rank.lean

tactic: ext x
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁶ : Fintype n
inst✝⁵ : Fintype o
inst✝⁴ : Fintype m
inst✝³ : Field R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
A : Matrix m n R
⊢ LinearMap.ker (Aᴴ * A).mulVecLin = LinearMap.ker A.mulVecLin
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁶ : Fintype n
inst✝⁵ : Fintype o
inst✝⁴ : Fintype m
inst✝³ : Field R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
A : Matrix m n R
x : n → R
⊢ x ∈ LinearMap.ker (Aᴴ * A).mulVecLin ↔ x ∈ LinearMap.ker A.mulVecLin

tactic: simp only [LinearMap.mem_ker, mulVecLin_apply, conjTranspose_mul_self_mulVec_eq_zero]
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁶ : Fintype n
inst✝⁵ : Fintype o
inst✝⁴ : Fintype m
inst✝³ : Field R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
A : Matrix m n R
x : n → R
⊢ x ∈ LinearMap.ker (Aᴴ * A).mulVecLin ↔ x ∈ LinearMap.ker A.mulVecLin
state_after: no goals
Theorem: CategoryTheory.Limits.colimitUncurryIsoColimitCompColim_ι_hom
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: rw [← cancel_mono (colimitUncurryIsoColimitCompColim F).inv]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit (uncurry.obj F)
inst✝ : HasColimit (F ⋙ colim)
j : J
k : K
⊢ colimit.ι (uncurry.obj F) (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom =
    colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit (uncurry.obj F)
inst✝ : HasColimit (F ⋙ colim)
j : J
k : K
⊢ (colimit.ι (uncurry.obj F) (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom) ≫
      (colimitUncurryIsoColimitCompColim F).inv =
    (colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j) ≫ (colimitUncurryIsoColimitCompColim F).inv

tactic: simp
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit (uncurry.obj F)
inst✝ : HasColimit (F ⋙ colim)
j : J
k : K
⊢ (colimit.ι (uncurry.obj F) (j, k) ≫ (colimitUncurryIsoColimitCompColim F).hom) ≫
      (colimitUncurryIsoColimitCompColim F).inv =
    (colimit.ι (F.obj j) k ≫ colimit.ι (F ⋙ colim) j) ≫ (colimitUncurryIsoColimitCompColim F).inv
state_after: no goals
Theorem: Fin.update_snoc_last
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
⊢ update (snoc p x) (last n) z = snoc p z
state_after: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
⊢ update (snoc p x) (last n) z j = snoc p z j

tactic: by_cases h : j.val < n
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
⊢ update (snoc p x) (last n) z j = snoc p z j
state_after: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ↑j < n
⊢ update (snoc p x) (last n) z j = snoc p z j

case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ¬↑j < n
⊢ update (snoc p x) (last n) z j = snoc p z j

tactic: have : j ≠ last n := ne_of_lt h
state_before: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ↑j < n
⊢ update (snoc p x) (last n) z j = snoc p z j
state_after: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ↑j < n
this : j ≠ last n
⊢ update (snoc p x) (last n) z j = snoc p z j

tactic: simp [h, update_noteq, this, snoc]
state_before: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ↑j < n
this : j ≠ last n
⊢ update (snoc p x) (last n) z j = snoc p z j
state_after: no goals

tactic: rw [eq_last_of_not_lt h]
state_before: case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ¬↑j < n
⊢ update (snoc p x) (last n) z j = snoc p z j
state_after: case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ¬↑j < n
⊢ update (snoc p x) (last n) z (last n) = snoc p z (last n)

tactic: simp
state_before: case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin (n + 1)
h : ¬↑j < n
⊢ update (snoc p x) (last n) z (last n) = snoc p z (last n)
state_after: no goals
Theorem: List.indexOf_getElem
File: Mathlib/Data/List/Nodup.lean

tactic: simp
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
l : List α
H : l.Nodup
i : ℕ
h : i < l.length
⊢ l.get ⟨indexOf l[i] l, ⋯⟩ = l.get ⟨i, h⟩
state_after: no goals
Theorem: PEquiv.toMatrix_refl
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: ext
state_before: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
⊢ (PEquiv.refl n).toMatrix = 1
state_after: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
i✝ j✝ : n
⊢ (PEquiv.refl n).toMatrix i✝ j✝ = 1 i✝ j✝

tactic: simp [toMatrix_apply, one_apply]
state_before: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
i✝ j✝ : n
⊢ (PEquiv.refl n).toMatrix i✝ j✝ = 1 i✝ j✝
state_after: no goals
Theorem: Set.uIoc_injective_left
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simpa only [uIoc_comm] using uIoc_injective_right a
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b b₁ b₂ c d x a : α
⊢ Injective (Ι a)
state_after: no goals
Theorem: Cardinal.ofENat_add
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: apply toENat_injOn <;> simp
state_before: m n : ℕ∞
⊢ ↑(m + n) = ↑m + ↑n
state_after: no goals
Theorem: MeasureTheory.pdf.IsUniform.measure_preimage
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: rwa [← map_apply_of_aemeasurable (hu.aemeasurable hns hnt) hA, hu, ProbabilityTheory.cond_apply',
  ENNReal.div_eq_inv_mul]
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : IsUniform X s ℙ μ
A : Set E
hA : MeasurableSet A
⊢ ℙ (X ⁻¹' A) = μ (s ∩ A) / μ s
state_after: no goals
Theorem: Derivation.comp_aeval_eq
File: Mathlib/Algebra/Polynomial/Derivation.lean

tactic: simp [-compAEval_apply, compAEval_eq]
state_before: R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
d✝ : Derivation R A M
a : A
d : Derivation R A M
f : R[X]
⊢ (AEval.of R M a).symm ((d.compAEval a) f) = (aeval a) (derivative f) • d a
state_after: no goals
Theorem: sdiff_sdiff_eq_sdiff_sup
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_sdiff_right', inf_eq_right.2 h]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : z ≤ x
⊢ x \ (y \ z) = x \ y ⊔ z
state_after: no goals
Theorem: Real.summable_one_div_nat_pow
File: Mathlib/Analysis/PSeries.lean

tactic: simp only [one_div, Real.summable_nat_pow_inv]
state_before: p : ℕ
⊢ (Summable fun n => 1 / ↑n ^ p) ↔ 1 < p
state_after: no goals
Theorem: Polynomial.bernoulli_def
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

tactic: rw [← sum_range_reflect, add_succ_sub_one, add_zero, bernoulli]
state_before: n : ℕ
⊢ bernoulli n = ∑ i ∈ range (n + 1), (monomial i) (_root_.bernoulli (n - i) * ↑(n.choose i))
state_after: n : ℕ
⊢ ∑ i ∈ range (n + 1), (monomial (n - i)) (_root_.bernoulli i * ↑(n.choose i)) =
    ∑ j ∈ range (n + 1), (monomial (n - j)) (_root_.bernoulli (n - (n - j)) * ↑(n.choose (n - j)))

tactic: apply sum_congr rfl
state_before: n : ℕ
⊢ ∑ i ∈ range (n + 1), (monomial (n - i)) (_root_.bernoulli i * ↑(n.choose i)) =
    ∑ j ∈ range (n + 1), (monomial (n - j)) (_root_.bernoulli (n - (n - j)) * ↑(n.choose (n - j)))
state_after: n : ℕ
⊢ ∀ x ∈ range (n + 1),
    (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
      (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))

tactic: rintro x hx
state_before: n : ℕ
⊢ ∀ x ∈ range (n + 1),
    (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
      (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
state_after: n x : ℕ
hx : x ∈ range (n + 1)
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))

tactic: rw [mem_range_succ_iff] at hx
state_before: n x : ℕ
hx : x ∈ range (n + 1)
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
state_after: n x : ℕ
hx : x ≤ n
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))

tactic: rw [choose_symm hx, tsub_tsub_cancel_of_le hx]
state_before: n x : ℕ
hx : x ≤ n
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
state_after: no goals
Theorem: Int.ModEq.mul_left'
File: Mathlib/Data/Int/ModEq.lean

tactic: obtain hc | rfl | hc := lt_trichotomy c 0
state_before: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ c * a ≡ c * b [ZMOD c * n]
state_after: case inl
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : c < 0
⊢ c * a ≡ c * b [ZMOD c * n]

case inr.inl
m n a b d : ℤ
h : a ≡ b [ZMOD n]
⊢ 0 * a ≡ 0 * b [ZMOD 0 * n]

case inr.inr
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : 0 < c
⊢ c * a ≡ c * b [ZMOD c * n]

tactic: rw [← neg_modEq_neg, ← modEq_neg, ← neg_mul, ← neg_mul, ← neg_mul]
state_before: case inl
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : c < 0
⊢ c * a ≡ c * b [ZMOD c * n]
state_after: case inl
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : c < 0
⊢ -c * a ≡ -c * b [ZMOD -c * n]

tactic: simp only [ModEq, mul_emod_mul_of_pos _ _ (neg_pos.2 hc), h.eq]
state_before: case inl
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : c < 0
⊢ -c * a ≡ -c * b [ZMOD -c * n]
state_after: no goals

tactic: simp only [zero_mul, ModEq.rfl]
state_before: case inr.inl
m n a b d : ℤ
h : a ≡ b [ZMOD n]
⊢ 0 * a ≡ 0 * b [ZMOD 0 * n]
state_after: no goals

tactic: simp only [ModEq, mul_emod_mul_of_pos _ _ hc, h.eq]
state_before: case inr.inr
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : 0 < c
⊢ c * a ≡ c * b [ZMOD c * n]
state_after: no goals
Theorem: HomologicalComplex.biprod_lift_snd_f
File: Mathlib/Algebra/Homology/HomologicalComplexBiprod.lean

tactic: rw [← comp_f, biprod.lift_snd]
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K L : HomologicalComplex C c
inst✝ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (L.X i)
M : HomologicalComplex C c
α : M ⟶ K
β : M ⟶ L
i : ι
⊢ (biprod.lift α β).f i ≫ biprod.snd.f i = β.f i
state_after: no goals
Theorem: CategoryTheory.leftDistributor_inv_comp_biproduct_π
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: simp [leftDistributor_inv, Preadditive.sum_comp, ← MonoidalCategory.whiskerLeft_comp,
  biproduct.ι_π, whiskerLeft_dite, comp_dite]
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
j : J
⊢ (leftDistributor X f).inv ≫ X ◁ biproduct.π f j = biproduct.π (fun j => X ⊗ f j) j
state_after: no goals
Theorem: Basis.equiv_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.equiv]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
⊢ (b.equiv b' e) (b i) = b' (e i)
state_after: no goals
Theorem: Subalgebra.restrictScalars_top
File: Mathlib/Algebra/Algebra/Subalgebra/Tower.lean

tactic: dsimp
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra S A
inst✝⁴ : Algebra R A
inst✝³ : Algebra S B
inst✝² : Algebra R B
inst✝¹ : IsScalarTower R S A
inst✝ : IsScalarTower R S B
⊢ ↑(restrictScalars R ⊤) = ↑⊤
state_after: no goals
Theorem: Nat.exists_prime_lt_and_le_two_mul_succ
File: Mathlib/NumberTheory/Bertrand.lean

tactic: by_cases h : p ≤ 2 * n
state_before: n q p : ℕ
prime_p : Prime p
covering : p ≤ 2 * q
H : n < q → ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
hn : n < p
⊢ ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
state_after: case pos
n q p : ℕ
prime_p : Prime p
covering : p ≤ 2 * q
H : n < q → ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
hn : n < p
h : p ≤ 2 * n
⊢ ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n

case neg
n q p : ℕ
prime_p : Prime p
covering : p ≤ 2 * q
H : n < q → ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
hn : n < p
h : ¬p ≤ 2 * n
⊢ ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n

tactic: exact H (lt_of_mul_lt_mul_left' (lt_of_lt_of_le (not_le.1 h) covering))
state_before: case neg
n q p : ℕ
prime_p : Prime p
covering : p ≤ 2 * q
H : n < q → ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
hn : n < p
h : ¬p ≤ 2 * n
⊢ ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
state_after: no goals

tactic: exact ⟨p, prime_p, hn, h⟩
state_before: case pos
n q p : ℕ
prime_p : Prime p
covering : p ≤ 2 * q
H : n < q → ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
hn : n < p
h : p ≤ 2 * n
⊢ ∃ p, Prime p ∧ n < p ∧ p ≤ 2 * n
state_after: no goals
Theorem: ContinuousMap.continuous_uncurry
File: Mathlib/Topology/CompactOpen.lean

tactic: apply continuous_of_continuous_uncurry
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace T
K : Set X
U : Set Y
inst✝¹ : LocallyCompactSpace X
inst✝ : LocallyCompactSpace Y
⊢ Continuous uncurry
state_after: case h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace T
K : Set X
U : Set Y
inst✝¹ : LocallyCompactSpace X
inst✝ : LocallyCompactSpace Y
⊢ Continuous (Function.uncurry fun x y => x.uncurry y)

tactic: rw [← (Homeomorph.prodAssoc _ _ _).comp_continuous_iff']
state_before: case h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace T
K : Set X
U : Set Y
inst✝¹ : LocallyCompactSpace X
inst✝ : LocallyCompactSpace Y
⊢ Continuous (Function.uncurry fun x y => x.uncurry y)
state_after: case h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace T
K : Set X
U : Set Y
inst✝¹ : LocallyCompactSpace X
inst✝ : LocallyCompactSpace Y
⊢ Continuous ((Function.uncurry fun x y => x.uncurry y) ∘ ⇑(Homeomorph.prodAssoc C(X, C(Y, Z)) X Y))

tactic: apply continuous_eval.comp (continuous_eval.prod_map continuous_id)
state_before: case h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace T
K : Set X
U : Set Y
inst✝¹ : LocallyCompactSpace X
inst✝ : LocallyCompactSpace Y
⊢ Continuous ((Function.uncurry fun x y => x.uncurry y) ∘ ⇑(Homeomorph.prodAssoc C(X, C(Y, Z)) X Y))
state_after: no goals
Theorem: isLittleO_coe_const_pow_of_one_lt
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simpa only [pow_one] using @isLittleO_pow_const_const_pow_of_one_lt R _ 1 _ hr
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝ : NormedRing R
r : ℝ
hr : 1 < r
⊢ Nat.cast =o[atTop] fun n => r ^ n
state_after: no goals
Theorem: Poly.sumsq_nonneg
File: Mathlib/NumberTheory/Dioph.lean

tactic: rw [sumsq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
x : α → ℕ
p : Poly α
ps : List (Poly α)
⊢ 0 ≤ (sumsq (p :: ps)) x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
x : α → ℕ
p : Poly α
ps : List (Poly α)
⊢ 0 ≤ (p * p + sumsq ps) x

tactic: exact add_nonneg (mul_self_nonneg _) (sumsq_nonneg _ ps)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
x : α → ℕ
p : Poly α
ps : List (Poly α)
⊢ 0 ≤ (p * p + sumsq ps) x
state_after: no goals
Theorem: MeasureTheory.AEEqFun.ext_iff
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : α →ₘ[μ] β
h : f = g
⊢ ↑f =ᶠ[ae μ] ↑g
state_after: no goals
Theorem: Rat.ofScientific_true_def
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: unfold Rat.ofScientific
state_before: m e : Nat
⊢ Rat.ofScientific m true e = mkRat (↑m) (10 ^ e)
state_after: m e : Nat
⊢ (if true = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e)

tactic: rw [normalize_eq_mkRat]
state_before: m e : Nat
⊢ (if true = true then normalize (↑m) (10 ^ e) ⋯ else ↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e)
state_after: m e : Nat
⊢ (if true = true then mkRat (↑m) (10 ^ e) else ↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e)

tactic: rfl
state_before: m e : Nat
⊢ (if true = true then mkRat (↑m) (10 ^ e) else ↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e)
state_after: no goals
Theorem: Surreal.Multiplication.P24_neg_left
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: rw [P24, P24, P2_neg_left, P4_neg_left]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ P24 x₁ x₂ y ↔ P24 (-x₂) (-x₁) y
state_after: no goals
Theorem: FractionalIdeal.spanSingleton_one
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: ext
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
⊢ spanSingleton S 1 = 1
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
⊢ x✝ ∈ spanSingleton S 1 ↔ x✝ ∈ 1

tactic: refine (mem_spanSingleton S).trans ((exists_congr ?_).trans (mem_one_iff S).symm)
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
⊢ x✝ ∈ spanSingleton S 1 ↔ x✝ ∈ 1
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
⊢ ∀ (a : R), a • 1 = x✝ ↔ (algebraMap R P) a = x✝

tactic: intro x'
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
⊢ ∀ (a : R), a • 1 = x✝ ↔ (algebraMap R P) a = x✝
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
x' : R
⊢ x' • 1 = x✝ ↔ (algebraMap R P) x' = x✝

tactic: rw [Algebra.smul_def, mul_one]
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
x' : R
⊢ x' • 1 = x✝ ↔ (algebraMap R P) x' = x✝
state_after: no goals
Theorem: Finsupp.mapRange_sub
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [hf', sub_apply, mapRange_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : SubNegZeroMonoid G
inst✝ : SubNegZeroMonoid H
f : G → H
hf : f 0 = 0
hf' : ∀ (x y : G), f (x - y) = f x - f y
v₁ v₂ : α →₀ G
x✝ : α
⊢ (mapRange f hf (v₁ - v₂)) x✝ = (mapRange f hf v₁ - mapRange f hf v₂) x✝
state_after: no goals
Theorem: Stream'.WSeq.think_congr
File: Mathlib/Data/Seq/WSeq.lean

tactic: unfold Equiv
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
⊢ s.think ~ʷ t.think
state_after: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) s.think t.think

tactic: simpa using h
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) s.think t.think
state_after: no goals
Theorem: Real.Angle.tan_eq_of_two_nsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_nsmul_eq_iff] at h
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ θ.tan = ψ.tan
state_after: θ ψ : Angle
h : θ = ψ ∨ θ = ψ + ↑π
⊢ θ.tan = ψ.tan

tactic: rcases h with (rfl | rfl)
state_before: θ ψ : Angle
h : θ = ψ ∨ θ = ψ + ↑π
⊢ θ.tan = ψ.tan
state_after: case inl
θ : Angle
⊢ θ.tan = θ.tan

case inr
ψ : Angle
⊢ (ψ + ↑π).tan = ψ.tan

tactic: rfl
state_before: case inl
θ : Angle
⊢ θ.tan = θ.tan
state_after: no goals

tactic: exact tan_add_pi _
state_before: case inr
ψ : Angle
⊢ (ψ + ↑π).tan = ψ.tan
state_after: no goals
Theorem: CategoryTheory.Limits.coprod.desc_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: ext <;> simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ V W X Y : C
inst✝ : HasBinaryCoproduct X Y
f : V ⟶ W
g : X ⟶ V
h : Y ⟶ V
⊢ desc g h ≫ f = desc (g ≫ f) (h ≫ f)
state_after: no goals