tasksource/leandojo huggingface dataset:
Theorem: measurable_tProd_mk
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: induction' l with i l ih
state_before: α : Type ?u.370249
β : Type ?u.370252
γ : Type ?u.370255
δ : Type u_1
δ' : Type ?u.370261
ι : Sort uι
s t u : Set α
π : δ → Type u_2
inst✝ : (x : δ) → MeasurableSpace (π x)
l : List δ
⊢ Measurable (TProd.mk l)

tactic: exact measurable_const
state_before: case nil
α : Type ?u.370249
β : Type ?u.370252
γ : Type ?u.370255
δ : Type u_1
δ' : Type ?u.370261
ι : Sort uι
s t u : Set α
π : δ → Type u_2
inst✝ : (x : δ) → MeasurableSpace (π x)
⊢ Measurable (TProd.mk [])

tactic: exact (measurable_pi_apply i).prod_mk ih
state_before: case cons
α : Type ?u.370249
β : Type ?u.370252
γ : Type ?u.370255
δ : Type u_1
δ' : Type ?u.370261
ι : Sort uι
s t u : Set α
π : δ → Type u_2
inst✝ : (x : δ) → MeasurableSpace (π x)
i : δ
l : List δ
ih : Measurable (TProd.mk l)
⊢ Measurable (TProd.mk (i :: l))
Theorem: Polynomial.map_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp only [map_C, forall_const, C_comp, eq_self_iff_true]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
p q : R[X]
⊢ ∀ (a : R), map f (comp (↑C a) q) = comp (map f (↑C a)) (map f q)

tactic: simp (config := { contextual := true }) only [Polynomial.map_add, add_comp, forall_const,
  imp_true_iff, eq_self_iff_true]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
p q : R[X]
⊢ ∀ (p q_1 : R[X]),
    map f (comp p q) = comp (map f p) (map f q) →
      map f (comp q_1 q) = comp (map f q_1) (map f q) → map f (comp (p + q_1) q) = comp (map f (p + q_1)) (map f q)

tactic: simp (config := { contextual := true }) only [pow_succ', ← mul_assoc, comp, forall_const,
  eval₂_mul_X, imp_true_iff, eq_self_iff_true, map_X, Polynomial.map_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
p q : R[X]
⊢ ∀ (n : ℕ) (a : R),
    map f (comp (↑C a * X ^ n) q) = comp (map f (↑C a * X ^ n)) (map f q) →
      map f (comp (↑C a * X ^ (n + 1)) q) = comp (map f (↑C a * X ^ (n + 1))) (map f q)
Theorem: RingHom.FiniteType.comp
File: Mathlib/RingTheory/FiniteType.lean

tactic: let _ : Algebra A B := f.toAlgebra
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : FiniteType g
hf : FiniteType f
⊢ FiniteType (RingHom.comp g f)

tactic: let _ : Algebra A C := (g.comp f).toAlgebra
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : FiniteType g
hf : FiniteType f
x✝ : Algebra A B := toAlgebra f
⊢ FiniteType (RingHom.comp g f)

tactic: let _ : Algebra B C := g.toAlgebra
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : FiniteType g
hf : FiniteType f
x✝¹ : Algebra A B := toAlgebra f
x✝ : Algebra A C := toAlgebra (RingHom.comp g f)
⊢ FiniteType (RingHom.comp g f)

tactic: exact @Algebra.FiniteType.trans A B C _ _ f.toAlgebra _ (g.comp f).toAlgebra g.toAlgebra
  ⟨by
    intro a b c
    simp [Algebra.smul_def, RingHom.map_mul, mul_assoc]
    rfl⟩
  hf hg
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : FiniteType g
hf : FiniteType f
x✝² : Algebra A B := toAlgebra f
x✝¹ : Algebra A C := toAlgebra (RingHom.comp g f)
x✝ : Algebra B C := toAlgebra g
⊢ FiniteType (RingHom.comp g f)

tactic: intro a b c
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : FiniteType g
hf : FiniteType f
x✝² : Algebra A B := toAlgebra f
x✝¹ : Algebra A C := toAlgebra (RingHom.comp g f)
x✝ : Algebra B C := toAlgebra g
⊢ ∀ (x : A) (y : B) (z : C), (x • y) • z = x • y • z

tactic: simp [Algebra.smul_def, RingHom.map_mul, mul_assoc]
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : FiniteType g
hf : FiniteType f
x✝² : Algebra A B := toAlgebra f
x✝¹ : Algebra A C := toAlgebra (RingHom.comp g f)
x✝ : Algebra B C := toAlgebra g
a : A
b : B
c : C
⊢ (a • b) • c = a • b • c

tactic: rfl
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : FiniteType g
hf : FiniteType f
x✝² : Algebra A B := toAlgebra f
x✝¹ : Algebra A C := toAlgebra (RingHom.comp g f)
x✝ : Algebra B C := toAlgebra g
a : A
b : B
c : C
⊢ ↑(algebraMap B C) (↑(algebraMap A B) a) * (↑(algebraMap B C) b * c) = ↑(algebraMap A C) a * (↑(algebraMap B C) b * c)
Theorem: compl_compl_himp_distrib
File: Mathlib/Order/Heyting/Basic.lean

tactic: refine' le_antisymm _ _
state_before: ι : Type ?u.165630
α : Type u_1
β : Type ?u.165636
inst✝ : HeytingAlgebra α
a✝ b✝ c a b : α
⊢ (a ⇨ b)ᶜᶜ = aᶜᶜ ⇨ bᶜᶜ

tactic: rw [le_himp_iff, ← compl_compl_inf_distrib]
state_before: case refine'_1
ι : Type ?u.165630
α : Type u_1
β : Type ?u.165636
inst✝ : HeytingAlgebra α
a✝ b✝ c a b : α
⊢ (a ⇨ b)ᶜᶜ ≤ aᶜᶜ ⇨ bᶜᶜ

tactic: exact compl_anti (compl_anti himp_inf_le)
state_before: case refine'_1
ι : Type ?u.165630
α : Type u_1
β : Type ?u.165636
inst✝ : HeytingAlgebra α
a✝ b✝ c a b : α
⊢ ((a ⇨ b) ⊓ a)ᶜᶜ ≤ bᶜᶜ

tactic: refine' le_compl_comm.1 ((compl_anti compl_sup_le_himp).trans _)
state_before: case refine'_2
ι : Type ?u.165630
α : Type u_1
β : Type ?u.165636
inst✝ : HeytingAlgebra α
a✝ b✝ c a b : α
⊢ aᶜᶜ ⇨ bᶜᶜ ≤ (a ⇨ b)ᶜᶜ

tactic: rw [compl_sup_distrib, le_compl_iff_disjoint_right, disjoint_right_comm, ←
  le_compl_iff_disjoint_right]
state_before: case refine'_2
ι : Type ?u.165630
α : Type u_1
β : Type ?u.165636
inst✝ : HeytingAlgebra α
a✝ b✝ c a b : α
⊢ (aᶜ ⊔ b)ᶜ ≤ (aᶜᶜ ⇨ bᶜᶜ)ᶜ

tactic: exact inf_himp_le
state_before: case refine'_2
ι : Type ?u.165630
α : Type u_1
β : Type ?u.165636
inst✝ : HeytingAlgebra α
a✝ b✝ c a b : α
⊢ aᶜᶜ ⊓ (aᶜᶜ ⇨ bᶜᶜ) ≤ bᶜᶜ
Theorem: AffineIndependent.injective
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: intro i j hij
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
⊢ Injective p

tactic: rw [affineIndependent_iff_linearIndependent_vsub _ _ j] at ha
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
i j : ι
hij : p i = p j
⊢ i = j

tactic: by_contra hij'
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
i j : ι
ha : LinearIndependent k fun i => p ↑i -ᵥ p j
hij : p i = p j
⊢ i = j

tactic: refine' ha.ne_zero ⟨i, hij'⟩ (vsub_eq_zero_iff_eq.mpr _)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
i j : ι
ha : LinearIndependent k fun i => p ↑i -ᵥ p j
hij : p i = p j
hij' : ¬i = j
⊢ False

tactic: simp_all only [ne_eq]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
i j : ι
ha : LinearIndependent k fun i => p ↑i -ᵥ p j
hij : p i = p j
hij' : ¬i = j
⊢ p ↑{ val := i, property := hij' } = p j
Theorem: Commute.geom_sum₂_succ_eq
File: Mathlib/Algebra/GeomSum.lean

tactic: simp_rw [mul_sum, sum_range_succ_comm, tsub_self, pow_zero, mul_one, add_right_inj, ← mul_assoc,
  (h.symm.pow_right _).eq, mul_assoc, ← pow_succ]
state_before: α✝ α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
⊢ ∑ i in range (n + 1), x ^ i * y ^ (n - i) = x ^ n + y * ∑ i in range n, x ^ i * y ^ (n - 1 - i)

tactic: refine' sum_congr rfl fun i hi => _
state_before: α✝ α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
⊢ ∑ i in range n, x ^ i * y ^ (n - i) = ∑ x_1 in range n, x ^ x_1 * y ^ (n - 1 - x_1 + 1)

tactic: suffices n - 1 - i + 1 = n - i by rw [this]
state_before: α✝ α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n i : ℕ
hi : i ∈ range n
⊢ x ^ i * y ^ (n - i) = x ^ i * y ^ (n - 1 - i + 1)

tactic: cases' n with n
state_before: α✝ α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n i : ℕ
hi : i ∈ range n
⊢ n - 1 - i + 1 = n - i

tactic: rw [this]
state_before: α✝ α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n i : ℕ
hi : i ∈ range n
this : n - 1 - i + 1 = n - i
⊢ x ^ i * y ^ (n - i) = x ^ i * y ^ (n - 1 - i + 1)

tactic: exact absurd (List.mem_range.mp hi) i.not_lt_zero
state_before: case zero
α✝ α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
i : ℕ
hi : i ∈ range Nat.zero
⊢ Nat.zero - 1 - i + 1 = Nat.zero - i

tactic: rw [tsub_add_eq_add_tsub (Nat.le_pred_of_lt (List.mem_range.mp hi)),
  tsub_add_cancel_of_le (Nat.succ_le_iff.mpr n.succ_pos)]
state_before: case succ
α✝ α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
i n : ℕ
hi : i ∈ range (Nat.succ n)
⊢ Nat.succ n - 1 - i + 1 = Nat.succ n - i
Theorem: Nat.Prime.not_coprime_iff_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: apply Iff.intro
state_before: m n : ℕ
⊢ ¬coprime m n ↔ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n

tactic: intro h
state_before: case mp
m n : ℕ
⊢ ¬coprime m n → ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n

tactic: exact
  ⟨minFac (gcd m n), minFac_prime h, (minFac_dvd (gcd m n)).trans (gcd_dvd_left m n),
    (minFac_dvd (gcd m n)).trans (gcd_dvd_right m n)⟩
state_before: case mp
m n : ℕ
h : ¬coprime m n
⊢ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n

tactic: intro h
state_before: case mpr
m n : ℕ
⊢ (∃ p, Prime p ∧ p ∣ m ∧ p ∣ n) → ¬coprime m n

tactic: cases' h with p hp
state_before: case mpr
m n : ℕ
h : ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
⊢ ¬coprime m n

tactic: apply Nat.not_coprime_of_dvd_of_dvd (Prime.one_lt hp.1) hp.2.1 hp.2.2
state_before: case mpr.intro
m n p : ℕ
hp : Prime p ∧ p ∣ m ∧ p ∣ n
⊢ ¬coprime m n
Theorem: PowerSeries.smul_eq_C_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext
state_before: R : Type u_1
inst✝ : Semiring R
f : PowerSeries R
a : R
⊢ a • f = ↑(C R) a * f

tactic: simp
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : PowerSeries R
a : R
n✝ : ℕ
⊢ ↑(coeff R n✝) (a • f) = ↑(coeff R n✝) (↑(C R) a * f)
Theorem: Set.einfsep_of_fintype
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: refine' eq_of_forall_le_iff fun _ => _
state_before: α : Type u_1
β : Type ?u.30517
inst✝² : EDist α
x y : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
⊢ einfsep s = Finset.inf (toFinset (offDiag s)) (uncurry edist)

tactic: simp_rw [le_einfsep_iff, imp_forall_iff, Finset.le_inf_iff, mem_toFinset, mem_offDiag,
  Prod.forall, uncurry_apply_pair, and_imp]
state_before: α : Type u_1
β : Type ?u.30517
inst✝² : EDist α
x y : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
x✝ : ℝ≥0∞
⊢ x✝ ≤ einfsep s ↔ x✝ ≤ Finset.inf (toFinset (offDiag s)) (uncurry edist)
Theorem: Finset.erase_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [erase_insert_eq_erase, erase_eq_of_not_mem h]
state_before: α : Type u_1
β : Type ?u.209994
γ : Type ?u.209997
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
h : ¬a ∈ s
⊢ erase (insert a s) a = s
Theorem: IsPrimitiveRoot.card_rootsOfUnity'
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: let e := h.zmodEquivZpowers
state_before: M : Type ?u.3542232
N : Type ?u.3542235
G : Type ?u.3542238
R : Type u_1
S : Type ?u.3542244
F : Type ?u.3542247
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ : Rˣ
h✝ : IsPrimitiveRoot ζ k
inst✝ : IsDomain R
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
⊢ Fintype.card { x // x ∈ rootsOfUnity n R } = ↑n

tactic: haveI F : Fintype (Subgroup.zpowers ζ) := Fintype.ofEquiv _ e.toEquiv
state_before: M : Type ?u.3542232
N : Type ?u.3542235
G : Type ?u.3542238
R : Type u_1
S : Type ?u.3542244
F : Type ?u.3542247
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ : Rˣ
h✝ : IsPrimitiveRoot ζ k
inst✝ : IsDomain R
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
e : ZMod ↑n ≃+ Additive { x // x ∈ Subgroup.zpowers ζ } := zmodEquivZpowers h
⊢ Fintype.card { x // x ∈ rootsOfUnity n R } = ↑n

tactic: calc
  Fintype.card (rootsOfUnity n R) = Fintype.card (Subgroup.zpowers ζ) :=
    Fintype.card_congr <| by rw [h.zpowers_eq]
  _ = Fintype.card (ZMod n) := (Fintype.card_congr e.toEquiv.symm)
  _ = n := ZMod.card n
state_before: M : Type ?u.3542232
N : Type ?u.3542235
G : Type ?u.3542238
R : Type u_1
S : Type ?u.3542244
F✝ : Type ?u.3542247
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ : Rˣ
h✝ : IsPrimitiveRoot ζ k
inst✝ : IsDomain R
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
e : ZMod ↑n ≃+ Additive { x // x ∈ Subgroup.zpowers ζ } := zmodEquivZpowers h
F : Fintype { x // x ∈ Subgroup.zpowers ζ }
⊢ Fintype.card { x // x ∈ rootsOfUnity n R } = ↑n

tactic: rw [h.zpowers_eq]
state_before: M : Type ?u.3542232
N : Type ?u.3542235
G : Type ?u.3542238
R : Type u_1
S : Type ?u.3542244
F✝ : Type ?u.3542247
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ : Rˣ
h✝ : IsPrimitiveRoot ζ k
inst✝ : IsDomain R
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
e : ZMod ↑n ≃+ Additive { x // x ∈ Subgroup.zpowers ζ } := zmodEquivZpowers h
F : Fintype { x // x ∈ Subgroup.zpowers ζ }
⊢ { x // x ∈ rootsOfUnity n R } ≃ { x // x ∈ Subgroup.zpowers ζ }
Theorem: mul_nonpos_iff
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [← neg_nonneg, neg_mul_eq_mul_neg, mul_nonneg_iff, neg_nonneg, neg_nonpos]
state_before: α : Type u
β : Type ?u.181819
inst✝ : LinearOrderedRing α
a b c : α
⊢ a * b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b
Theorem: Int.eq_zero_or_eq_zero_of_mul_eq_zero
File: Mathlib/Init/Data/Int/Order.lean

tactic: have : 0 < a * b := Int.mul_pos hlt₁ hlt₂
state_before: a b : ℤ
h : a * b = 0
hlt₁ : 0 < a
hlt₂ : 0 < b
⊢ a = 0 ∨ b = 0

tactic: rw [h] at this
state_before: a b : ℤ
h : a * b = 0
hlt₁ : 0 < a
hlt₂ : 0 < b
this : 0 < a * b
⊢ a = 0 ∨ b = 0

tactic: exact absurd this (lt_irrefl _)
state_before: a b : ℤ
h : a * b = 0
hlt₁ : 0 < a
hlt₂ : 0 < b
this : 0 < 0
⊢ a = 0 ∨ b = 0

tactic: have : 0 > a * b := Int.mul_neg_of_pos_of_neg hlt₁ hgt₂
state_before: a b : ℤ
h : a * b = 0
hlt₁ : 0 < a
hgt₂ : b < 0
⊢ a = 0 ∨ b = 0

tactic: rw [h] at this
state_before: a b : ℤ
h : a * b = 0
hlt₁ : 0 < a
hgt₂ : b < 0
this : 0 > a * b
⊢ a = 0 ∨ b = 0

tactic: exact absurd this (lt_irrefl _)
state_before: a b : ℤ
h : a * b = 0
hlt₁ : 0 < a
hgt₂ : b < 0
this : 0 > 0
⊢ a = 0 ∨ b = 0

tactic: have : 0 > a * b := Int.mul_neg_of_neg_of_pos hgt₁ hlt₂
state_before: a b : ℤ
h : a * b = 0
hgt₁ : a < 0
hlt₂ : 0 < b
⊢ a = 0 ∨ b = 0

tactic: rw [h] at this
state_before: a b : ℤ
h : a * b = 0
hgt₁ : a < 0
hlt₂ : 0 < b
this : 0 > a * b
⊢ a = 0 ∨ b = 0

tactic: exact absurd this (lt_irrefl _)
state_before: a b : ℤ
h : a * b = 0
hgt₁ : a < 0
hlt₂ : 0 < b
this : 0 > 0
⊢ a = 0 ∨ b = 0

tactic: have : 0 < a * b := Int.mul_pos_of_neg_of_neg hgt₁ hgt₂
state_before: a b : ℤ
h : a * b = 0
hgt₁ : a < 0
hgt₂ : b < 0
⊢ a = 0 ∨ b = 0

tactic: rw [h] at this
state_before: a b : ℤ
h : a * b = 0
hgt₁ : a < 0
hgt₂ : b < 0
this : 0 < a * b
⊢ a = 0 ∨ b = 0

tactic: exact absurd this (lt_irrefl _)
state_before: a b : ℤ
h : a * b = 0
hgt₁ : a < 0
hgt₂ : b < 0
this : 0 < 0
⊢ a = 0 ∨ b = 0
Theorem: Rat.inv_def''
File: Mathlib/Data/Rat/Lemmas.lean

tactic: conv_lhs => rw [← @num_den q]
state_before: q : ℚ
⊢ q⁻¹ = ↑q.den / ↑q.num

tactic: rw [inv_def', divInt_eq_div]
state_before: q : ℚ
⊢ (q.num /. ↑q.den)⁻¹ = ↑q.den / ↑q.num

tactic: rfl
state_before: q : ℚ
⊢ ↑↑q.den / ↑q.num = ↑q.den / ↑q.num
Theorem: MeasureTheory.lintegral_const
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← SimpleFunc.const_lintegral, ← SimpleFunc.lintegral_eq_lintegral, SimpleFunc.coe_const]
state_before: α : Type u_1
β : Type ?u.74036
γ : Type ?u.74039
δ : Type ?u.74042
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
⊢ (∫⁻ (x : α), c ∂μ) = c * ↑↑μ univ

tactic: rfl
state_before: α : Type u_1
β : Type ?u.74036
γ : Type ?u.74039
δ : Type ?u.74042
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
⊢ (∫⁻ (x : α), c ∂μ) = ∫⁻ (a : α), Function.const α c a ∂μ
Theorem: PowerSeries.ext
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← coeff_def]
state_before: R : Type u_1
inst✝ : Semiring R
φ ψ : PowerSeries R
h : ∀ (n : ℕ), ↑(coeff R n) φ = ↑(coeff R n) ψ
n : Unit →₀ ℕ
⊢ ↑(MvPowerSeries.coeff R n) φ = ↑(MvPowerSeries.coeff R n) ψ

tactic: rfl
state_before: R : Type u_1
inst✝ : Semiring R
φ ψ : PowerSeries R
h : ∀ (n : ℕ), ↑(coeff R n) φ = ↑(coeff R n) ψ
n : Unit →₀ ℕ
⊢ ↑n () = ?m.2202640

R : Type u_1
inst✝ : Semiring R
φ ψ : PowerSeries R
h : ∀ (n : ℕ), ↑(coeff R n) φ = ↑(coeff R n) ψ
n : Unit →₀ ℕ
⊢ ℕ

tactic: apply h
state_before: R : Type u_1
inst✝ : Semiring R
φ ψ : PowerSeries R
h : ∀ (n : ℕ), ↑(coeff R n) φ = ↑(coeff R n) ψ
n : Unit →₀ ℕ
⊢ ↑(coeff R ?m.2202640) φ = ↑(coeff R ?m.2202640) ψ
Theorem: InnerProductSpace.Core.inner_add_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, inner_add_left, RingHom.map_add]
state_before: 𝕜 : Type u_1
E : Type ?u.362411
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y z : F
⊢ inner x (y + z) = inner x y + inner x z

tactic: simp only [inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type ?u.362411
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y z : F
⊢ ↑(starRingEnd 𝕜) (inner y x) + ↑(starRingEnd 𝕜) (inner z x) = inner x y + inner x z
Theorem: List.count_erase_of_ne
File: Mathlib/Data/List/Count.lean

tactic: rw [count_erase, if_neg ab, tsub_zero]
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
l : List α
⊢ count a (List.erase l b) = count a l
Theorem: hnot_inf_distrib
File: Mathlib/Order/Heyting/Basic.lean

tactic: simp_rw [← top_sdiff', sdiff_inf_distrib]
state_before: ι : Type ?u.170618
α : Type u_1
β : Type ?u.170624
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢(a ⊓ b) = ￢a ⊔ ￢b
Theorem: Primrec.subtype_val_iff
File: Mathlib/Computability/Primrec.lean

tactic: letI := Primcodable.subtype hp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.354442
σ : Type ?u.354445
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : β → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
f : α → Subtype p
⊢ (Primrec fun a => ↑(f a)) ↔ Primrec f

tactic: refine' ⟨fun h => _, fun hf => subtype_val.comp hf⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.354442
σ : Type ?u.354445
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : β → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
f : α → Subtype p
this : Primcodable (Subtype p) := Primcodable.subtype hp
⊢ (Primrec fun a => ↑(f a)) ↔ Primrec f

tactic: refine' Nat.Primrec.of_eq h fun n => _
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.354442
σ : Type ?u.354445
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : β → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
f : α → Subtype p
this : Primcodable (Subtype p) := Primcodable.subtype hp
h : Primrec fun a => ↑(f a)
⊢ Primrec f

tactic: cases' @decode α _ n with a
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.354442
σ : Type ?u.354445
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : β → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
f : α → Subtype p
this : Primcodable (Subtype p) := Primcodable.subtype hp
h : Primrec fun a => ↑(f a)
n : ℕ
⊢ encode (Option.map (fun a => ↑(f a)) (decode n)) = encode (Option.map f (decode n))

tactic: simp
state_before: case some
α : Type u_2
β : Type u_1
γ : Type ?u.354442
σ : Type ?u.354445
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : β → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
f : α → Subtype p
this : Primcodable (Subtype p) := Primcodable.subtype hp
h : Primrec fun a => ↑(f a)
n : ℕ
a : α
⊢ encode (Option.map (fun a => ↑(f a)) (some a)) = encode (Option.map f (some a))

tactic: rfl
state_before: case some
α : Type u_2
β : Type u_1
γ : Type ?u.354442
σ : Type ?u.354445
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : β → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
f : α → Subtype p
this : Primcodable (Subtype p) := Primcodable.subtype hp
h : Primrec fun a => ↑(f a)
n : ℕ
a : α
⊢ Nat.succ (encode ↑(f a)) = encode (some (f a))

tactic: rfl
state_before: case none
α : Type u_2
β : Type u_1
γ : Type ?u.354442
σ : Type ?u.354445
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : β → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
f : α → Subtype p
this : Primcodable (Subtype p) := Primcodable.subtype hp
h : Primrec fun a => ↑(f a)
n : ℕ
⊢ encode (Option.map (fun a => ↑(f a)) none) = encode (Option.map f none)
Theorem: ForInStep.bindList_append
File: Std/Control/ForInStep/Lemmas.lean

tactic: induction l₁ generalizing s <;> simp [*]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
s : ForInStep β
l₁ l₂ : List α
⊢ bindList f (l₁ ++ l₂) s = do
    let x ← bindList f l₁ s
    bindList f l₂ x
Theorem: nhdsWithin_eq_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin_restrict t h₀ h₁, nhdsWithin_restrict u h₀ h₁, h₂]
state_before: α : Type u_1
β : Type ?u.12224
γ : Type ?u.12227
δ : Type ?u.12230
inst✝ : TopologicalSpace α
a : α
s t u : Set α
h₀ : a ∈ s
h₁ : IsOpen s
h₂ : t ∩ s = u ∩ s
⊢ 𝓝[t] a = 𝓝[u] a
Theorem: Filter.bliminf_true
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [bliminf_eq, liminf_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.57903
ι : Type ?u.57906
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
⊢ (bliminf u f fun x => True) = liminf u f
Theorem: MeasureTheory.Measure.mapₗ_mk_apply_of_aemeasurable
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [map, hf]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.175590
δ : Type ?u.175593
ι : Type ?u.175596
R : Type ?u.175599
R' : Type ?u.175602
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
hf : AEMeasurable f
⊢ ↑(mapₗ (AEMeasurable.mk f hf)) μ = map f μ
Theorem: PicardLindelof.FunSpace.mem_closedBall
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: rw [f.map_t₀']
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
t : ↑(Icc v.tMin v.tMax)
⊢ dist (toFun f t) v.x₀ = dist (toFun f t) (toFun f v.t₀)
Theorem: MvPolynomial.totalDegree_add_eq_right_of_totalDegree_lt
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: rw [add_comm, totalDegree_add_eq_left_of_totalDegree_lt h]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.448839
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q✝ p q : MvPolynomial σ R
h : totalDegree q < totalDegree p
⊢ totalDegree (q + p) = totalDegree p
Theorem: GeneralizedContinuedFraction.exists_conts_b_of_denom
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simpa
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
B : K
nth_denom_eq : denominators g n = B
⊢ ∃ conts, continuants g n = conts ∧ conts.b = B
Theorem: CategoryTheory.Subobject.map_id
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: induction' x using Quotient.inductionOn' with f
state_before: C : Type u₁
inst✝¹ : Category C
X Y Z : C
D : Type u₂
inst✝ : Category D
x : Subobject X
⊢ (map (𝟙 X)).obj x = x

tactic: exact Quotient.sound ⟨MonoOver.mapId.app f⟩
state_before: case h
C : Type u₁
inst✝¹ : Category C
X Y Z : C
D : Type u₂
inst✝ : Category D
f : MonoOver X
⊢ (map (𝟙 X)).obj (Quotient.mk'' f) = Quotient.mk'' f