tasksource/leandojo huggingface dataset:
Theorem: RatFunc.num_div_dvd
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [num_div _ q, C_mul_dvd]
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ num (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) ∣ p

tactic: exact EuclideanDomain.div_dvd_of_dvd (gcd_dvd_left p q)
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ p / gcd p q ∣ p

tactic: simpa only [Ne.def, inv_eq_zero, Polynomial.leadingCoeff_eq_zero] using right_div_gcd_ne_zero hq
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ (leadingCoeff (q / gcd p q))⁻¹ ≠ 0
Theorem: Int.le_coe_nat_sub
File: Mathlib/Data/Int/Lemmas.lean

tactic: by_cases h : m ≥ n
state_before: m n : ℕ
⊢ ↑m - ↑n ≤ ↑(m - n)

tactic: exact le_of_eq (Int.ofNat_sub h).symm
state_before: case pos
m n : ℕ
h : m ≥ n
⊢ ↑m - ↑n ≤ ↑(m - n)

tactic: simp [le_of_not_ge h, ofNat_le]
state_before: case neg
m n : ℕ
h : ¬m ≥ n
⊢ ↑m - ↑n ≤ ↑(m - n)
Theorem: HomologicalComplex.Hom.comm
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: by_cases hij : c.Rel i j
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : Hom A B
i j : ι
⊢ HomologicalComplex.Hom.f f i ≫ d B i j = d A i j ≫ HomologicalComplex.Hom.f f j

tactic: . rw [A.shape i j hij, B.shape i j hij, comp_zero, zero_comp]
state_before: case neg
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : Hom A B
i j : ι
hij : ¬ComplexShape.Rel c i j
⊢ HomologicalComplex.Hom.f f i ≫ d B i j = d A i j ≫ HomologicalComplex.Hom.f f j

tactic: exact f.comm' i j hij
state_before: case pos
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : Hom A B
i j : ι
hij : ComplexShape.Rel c i j
⊢ HomologicalComplex.Hom.f f i ≫ d B i j = d A i j ≫ HomologicalComplex.Hom.f f j

tactic: rw [A.shape i j hij, B.shape i j hij, comp_zero, zero_comp]
state_before: case neg
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : Hom A B
i j : ι
hij : ¬ComplexShape.Rel c i j
⊢ HomologicalComplex.Hom.f f i ≫ d B i j = d A i j ≫ HomologicalComplex.Hom.f f j
Theorem: MulActionHom.comp_id
File: Mathlib/Algebra/Hom/GroupAction.lean

tactic: rw [comp_apply, id_apply]
state_before: M' : Type u_1
X : Type u_2
inst✝²³ : SMul M' X
Y : Type u_3
inst✝²² : SMul M' Y
Z : Type ?u.48568
inst✝²¹ : SMul M' Z
M : Type ?u.48575
inst✝²⁰ : Monoid M
A : Type ?u.48581
inst✝¹⁹ : AddMonoid A
inst✝¹⁸ : DistribMulAction M A
A' : Type ?u.48609
inst✝¹⁷ : AddGroup A'
inst✝¹⁶ : DistribMulAction M A'
B : Type ?u.48885
inst✝¹⁵ : AddMonoid B
inst✝¹⁴ : DistribMulAction M B
B' : Type ?u.48911
inst✝¹³ : AddGroup B'
inst✝¹² : DistribMulAction M B'
C : Type ?u.49187
inst✝¹¹ : AddMonoid C
inst✝¹⁰ : DistribMulAction M C
R : Type ?u.49213
inst✝⁹ : Semiring R
inst✝⁸ : MulSemiringAction M R
R' : Type ?u.49240
inst✝⁷ : Ring R'
inst✝⁶ : MulSemiringAction M R'
S : Type ?u.49436
inst✝⁵ : Semiring S
inst✝⁴ : MulSemiringAction M S
S' : Type ?u.49463
inst✝³ : Ring S'
inst✝² : MulSemiringAction M S'
T : Type ?u.49659
inst✝¹ : Semiring T
inst✝ : MulSemiringAction M T
f : X →[M'] Y
x : X
⊢ ↑(comp f (MulActionHom.id M')) x = ↑f x
Theorem: affineCombination_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [← vsub_vadd (s.affineCombination k p w) (s.affineCombination k p w₁),
  AffineSubspace.vadd_mem_iff_mem_direction _ (left_mem_affineSpan_pair _ _ _),
  direction_affineSpan, s.affineCombination_vsub, Set.pair_comm,
  weightedVSub_mem_vectorSpan_pair h _ hw₂ hw₁]
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
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
x✝ : ∑ i in s, w i = 1
hw₁ : ∑ i in s, w₁ i = 1
hw₂ : ∑ i in s, w₂ i = 1
⊢ ↑(Finset.affineCombination k s p) w ∈
      affineSpan k {↑(Finset.affineCombination k s p) w₁, ↑(Finset.affineCombination k s p) w₂} ↔
    ∃ r, ∀ (i : ι), i ∈ s → w i = r * (w₂ i - w₁ i) + w₁ i

tactic: simp only [Pi.sub_apply, sub_eq_iff_eq_add]
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
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
x✝ : ∑ i in s, w i = 1
hw₁ : ∑ i in s, w₁ i = 1
hw₂ : ∑ i in s, w₂ i = 1
⊢ (∃ r, ∀ (i : ι), i ∈ s → (w - w₁) i = r * (w₂ i - w₁ i)) ↔ ∃ r, ∀ (i : ι), i ∈ s → w i = r * (w₂ i - w₁ i) + w₁ i

tactic: simp_all only [Pi.sub_apply, Finset.sum_sub_distrib, sub_self]
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
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
x✝ : ∑ i in s, w i = 1
hw₁ : ∑ i in s, w₁ i = 1
hw₂ : ∑ i in s, w₂ i = 1
⊢ ∑ i in s, (w - w₁) i = 0
Theorem: LinearMap.toMatrixAlgEquiv_apply
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: simp [LinearMap.toMatrixAlgEquiv, LinearMap.toMatrix_apply]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2330336
m : Type ?u.2330339
n : Type u_3
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_2
M₂ : Type ?u.2330363
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2330865
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₁
i j : n
⊢ ↑(toMatrixAlgEquiv v₁) f i j = ↑(↑v₁.repr (↑f (↑v₁ j))) i
Theorem: Nat.Primrec'.cons
File: Mathlib/Computability/Primrec.lean

tactic: simp [*]
state_before: n m : ℕ
f : Vector ℕ n → ℕ
g : Vector ℕ n → Vector ℕ m
hf : Primrec' f
hg : Vec g
i : Fin (Nat.succ m)
⊢ Primrec' fun v => Vector.get ((fun v => f v ::ᵥ g v) v) 0

tactic: simp [hg i]
state_before: n m : ℕ
f : Vector ℕ n → ℕ
g : Vector ℕ n → Vector ℕ m
hf : Primrec' f
hg : Vec g
i✝ : Fin (Nat.succ m)
i : Fin m
⊢ Primrec' fun v => Vector.get ((fun v => f v ::ᵥ g v) v) (Fin.succ i)
Theorem: Real.rpow_le_rpow_left_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: have x_pos : 0 < x := lt_trans zero_lt_one hx
state_before: x y z : ℝ
hx : 1 < x
⊢ x ^ y ≤ x ^ z ↔ y ≤ z

tactic: rw [← log_le_log (rpow_pos_of_pos x_pos y) (rpow_pos_of_pos x_pos z), log_rpow x_pos,
  log_rpow x_pos, mul_le_mul_right (log_pos hx)]
state_before: x y z : ℝ
hx : 1 < x
x_pos : 0 < x
⊢ x ^ y ≤ x ^ z ↔ y ≤ z
Theorem: NNReal.rpow_inv_rpow_self
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: field_simp [← rpow_mul]
state_before: y : ℝ
hy : y ≠ 0
x : ℝ≥0
⊢ (x ^ y) ^ (1 / y) = x
Theorem: Polynomial.rootSet_prod
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp only [rootSet, ← Finset.mem_coe]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : Finset.prod s f ≠ 0
⊢ rootSet (Finset.prod s f) S = ⋃ (i : ι) (_ : i ∈ s), rootSet (f i) S

tactic: rw [Polynomial.map_prod, roots_prod, Finset.bind_toFinset, s.val_toFinset, Finset.coe_biUnion]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : Finset.prod s f ≠ 0
⊢ ↑(Multiset.toFinset (roots (map (algebraMap R S) (Finset.prod s f)))) =
    ⋃ (i : ι) (_ : i ∈ ↑s), ↑(Multiset.toFinset (roots (map (algebraMap R S) (f i))))

tactic: rwa [← Polynomial.map_prod, Ne, map_eq_zero]
state_before: case a
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : Finset.prod s f ≠ 0
⊢ ∏ i in s, map (algebraMap R S) (f i) ≠ 0
Theorem: Multiset.attach_cons
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [List.map_pmap]
state_before: α : Type u_1
β : Type ?u.143075
γ : Type ?u.143078
a : α
m : Multiset α
l : List α
⊢ List.pmap mk l (_ : ∀ (x : α), x ∈ l → (fun a_2 => a_2 ∈ a ::ₘ Quotient.mk (isSetoid α) l) x) =
    List.map (fun p => { val := ↑p, property := (_ : ↑p ∈ a ::ₘ Quotient.mk (isSetoid α) l) })
      (List.pmap mk l (_ : ∀ (_a : α), _a ∈ Quotient.mk (isSetoid α) l → _a ∈ Quotient.mk (isSetoid α) l))

tactic: exact List.pmap_congr _ fun _ _ _ _ => Subtype.eq rfl
state_before: α : Type u_1
β : Type ?u.143075
γ : Type ?u.143078
a : α
m : Multiset α
l : List α
⊢ List.pmap mk l (_ : ∀ (x : α), x ∈ l → (fun a_2 => a_2 ∈ a ::ₘ Quotient.mk (isSetoid α) l) x) =
    List.pmap
      (fun a_1 h =>
        { val := ↑{ val := a_1, property := h },
          property := (_ : ↑{ val := a_1, property := h } ∈ a ::ₘ Quotient.mk (isSetoid α) l) })
      l (_ : ∀ (_a : α), _a ∈ Quotient.mk (isSetoid α) l → _a ∈ Quotient.mk (isSetoid α) l)
Theorem: Polynomial.ofFinsupp_pow
File: Mathlib/Data/Polynomial/Basic.lean

tactic: change _ = npowRec n _
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : AddMonoidAlgebra R ℕ
n : ℕ
⊢ { toFinsupp := a ^ n } = { toFinsupp := a } ^ n

tactic: induction n with
| zero        => simp [npowRec]
| succ n n_ih => simp [npowRec, n_ih, pow_succ]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : AddMonoidAlgebra R ℕ
n : ℕ
⊢ { toFinsupp := a ^ n } = npowRec n { toFinsupp := a }

tactic: simp [npowRec]
state_before: case zero
R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := a ^ Nat.zero } = npowRec Nat.zero { toFinsupp := a }

tactic: simp [npowRec, n_ih, pow_succ]
state_before: case succ
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : AddMonoidAlgebra R ℕ
n : ℕ
n_ih : { toFinsupp := a ^ n } = npowRec n { toFinsupp := a }
⊢ { toFinsupp := a ^ Nat.succ n } = npowRec (Nat.succ n) { toFinsupp := a }
Theorem: MeasureTheory.Measure.integral_comp_mul_left
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: simp_rw [← smul_eq_mul, Measure.integral_comp_smul, FiniteDimensional.finrank_self, pow_one]
state_before: E : Type ?u.85697
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
g : ℝ → F
a : ℝ
⊢ (∫ (x : ℝ), g (a * x)) = abs a⁻¹ • ∫ (y : ℝ), g y
Theorem: IntermediateField.minpoly_gen
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [← AdjoinSimple.algebraMap_gen F α] at h
state_before: F : Type u_1
inst✝⁴ : Field F
E : Type u_2
inst✝³ : Field E
inst✝² : Algebra F E
α✝ : E
K : Type ?u.813260
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
h : IsIntegral F α
⊢ minpoly F (AdjoinSimple.gen F α) = minpoly F α

tactic: have inj := (algebraMap F⟮α⟯ E).injective
state_before: F : Type u_1
inst✝⁴ : Field F
E : Type u_2
inst✝³ : Field E
inst✝² : Algebra F E
α✝ : E
K : Type ?u.813260
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
h : IsIntegral F (↑(algebraMap { x // x ∈ F⟮α⟯ } E) (AdjoinSimple.gen F α))
⊢ minpoly F (AdjoinSimple.gen F α) = minpoly F α

tactic: exact
  minpoly.eq_of_algebraMap_eq inj ((isIntegral_algebraMap_iff inj).mp h)
    (AdjoinSimple.algebraMap_gen _ _).symm
state_before: F : Type u_1
inst✝⁴ : Field F
E : Type u_2
inst✝³ : Field E
inst✝² : Algebra F E
α✝ : E
K : Type ?u.813260
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
h : IsIntegral F (↑(algebraMap { x // x ∈ F⟮α⟯ } E) (AdjoinSimple.gen F α))
inj : Function.Injective ↑(algebraMap { x // x ∈ F⟮α⟯ } E)
⊢ minpoly F (AdjoinSimple.gen F α) = minpoly F α
Theorem: Complex.cpow_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp [hx, cpow_def]
state_before: x : ℂ
hx : x = 0
⊢ x ^ 1 = x

tactic: rw [cpow_def, if_neg (one_ne_zero : (1 : ℂ) ≠ 0), if_neg hx, mul_one, exp_log hx]
state_before: x : ℂ
hx : ¬x = 0
⊢ x ^ 1 = x
Theorem: MeasureTheory.Measure.add_haar_ball_mul_of_pos
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: have : ball (0 : E) (r * s) = r • ball (0 : E) s := by
  simp only [_root_.smul_ball hr.ne' (0 : E) s, Real.norm_eq_abs, abs_of_nonneg hr.le, smul_zero]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1974470
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
⊢ ↑↑μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * ↑↑μ (ball 0 s)

tactic: simp only [this, add_haar_smul, abs_of_nonneg hr.le, add_haar_ball_center, abs_pow]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1974470
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
this : ball 0 (r * s) = r • ball 0 s
⊢ ↑↑μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * ↑↑μ (ball 0 s)

tactic: simp only [_root_.smul_ball hr.ne' (0 : E) s, Real.norm_eq_abs, abs_of_nonneg hr.le, smul_zero]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1974470
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
⊢ ball 0 (r * s) = r • ball 0 s
Theorem: Int.cast_pos
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: rw [← cast_zero, cast_lt]
state_before: F : Type ?u.18775
ι : Type ?u.18778
α : Type u_1
β : Type ?u.18784
inst✝¹ : OrderedRing α
inst✝ : Nontrivial α
n : ℤ
⊢ 0 < ↑n ↔ 0 < n
Theorem: IsROrC.one_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_one, ofReal_re]
state_before: K : Type u_1
E : Type ?u.1627867
inst✝ : IsROrC K
⊢ ↑re 1 = 1
Theorem: MeasureTheory.unifIntegrable_zero_meas
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
inst✝ : MeasurableSpace α
p : ℝ≥0∞
f : ι → α → β
ε : ℝ
x✝² : 0 < ε
i : ι
s : Set α
x✝¹ : MeasurableSet s
x✝ : ↑↑0 s ≤ ENNReal.ofReal 1
⊢ snorm (Set.indicator s (f i)) p 0 ≤ ENNReal.ofReal ε
Theorem: MeasureTheory.Memℒp.toLp_congr
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp [toLp, hfg]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.347109
G : Type ?u.347112
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : Memℒp f p
hg : Memℒp g p
hfg : f =ᵐ[μ] g
⊢ toLp f hf = toLp g hg
Theorem: Nat.mul_div_le
File: Std/Data/Nat/Lemmas.lean

tactic: match n, Nat.eq_zero_or_pos n with
| _, Or.inl rfl => rw [Nat.zero_mul]; exact m.zero_le
| n, Or.inr h => rw [Nat.mul_comm, ← Nat.le_div_iff_mul_le h]; exact Nat.le_refl _
state_before: m n : Nat
⊢ n * (m / n) ≤ m

tactic: rw [Nat.zero_mul]
state_before: m n : Nat
⊢ 0 * (m / 0) ≤ m

tactic: exact m.zero_le
state_before: m n : Nat
⊢ 0 ≤ m

tactic: rw [Nat.mul_comm, ← Nat.le_div_iff_mul_le h]
state_before: m n✝ n : Nat
h : n > 0
⊢ n * (m / n) ≤ m

tactic: exact Nat.le_refl _
state_before: m n✝ n : Nat
h : n > 0
⊢ m / n ≤ m / n
Theorem: Finset.image_image₂_antidistrib_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_3
α' : Type u_5
β : Type u_4
β' : Type ?u.95037
γ : Type u_2
γ' : Type ?u.95043
δ : Type u_1
δ' : Type ?u.95049
ε : Type ?u.95052
ε' : Type ?u.95055
ζ : Type ?u.95058
ζ' : Type ?u.95061
ν : Type ?u.95064
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β → α' → δ
g' : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ ↑(image g (image₂ f s t)) = ↑(image₂ f' t (image g' s))

tactic: exact image_image2_antidistrib_right h_antidistrib
state_before: α : Type u_3
α' : Type u_5
β : Type u_4
β' : Type ?u.95037
γ : Type u_2
γ' : Type ?u.95043
δ : Type u_1
δ' : Type ?u.95049
ε : Type ?u.95052
ε' : Type ?u.95055
ζ : Type ?u.95058
ζ' : Type ?u.95061
ν : Type ?u.95064
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β → α' → δ
g' : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ g '' image2 f ↑s ↑t = image2 f' (↑t) (g' '' ↑s)
Theorem: Valuation.map_sum_le
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: refine'
  Finset.induction_on s (fun _ => v.map_zero ▸ zero_le')
    (fun a s has ih hf => _) hf
state_before: K : Type ?u.625793
F : Type ?u.625796
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type ?u.625808
Γ''₀ : Type ?u.625811
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v : Valuation R Γ₀
x y z : R
ι : Type u_1
s : Finset ι
f : ι → R
g : Γ₀
hf : ∀ (i : ι), i ∈ s → ↑v (f i) ≤ g
⊢ ↑v (∑ i in s, f i) ≤ g

tactic: rw [Finset.forall_mem_insert] at hf
state_before: K : Type ?u.625793
F : Type ?u.625796
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type ?u.625808
Γ''₀ : Type ?u.625811
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v : Valuation R Γ₀
x y z : R
ι : Type u_1
s✝ : Finset ι
f : ι → R
g : Γ₀
hf✝ : ∀ (i : ι), i ∈ s✝ → ↑v (f i) ≤ g
a : ι
s : Finset ι
has : ¬a ∈ s
ih : (∀ (i : ι), i ∈ s → ↑v (f i) ≤ g) → ↑v (∑ i in s, f i) ≤ g
hf : ∀ (i : ι), i ∈ insert a s → ↑v (f i) ≤ g
⊢ ↑v (∑ i in insert a s, f i) ≤ g

tactic: rw [Finset.sum_insert has]
state_before: K : Type ?u.625793
F : Type ?u.625796
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type ?u.625808
Γ''₀ : Type ?u.625811
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v : Valuation R Γ₀
x y z : R
ι : Type u_1
s✝ : Finset ι
f : ι → R
g : Γ₀
hf✝ : ∀ (i : ι), i ∈ s✝ → ↑v (f i) ≤ g
a : ι
s : Finset ι
has : ¬a ∈ s
ih : (∀ (i : ι), i ∈ s → ↑v (f i) ≤ g) → ↑v (∑ i in s, f i) ≤ g
hf : ↑v (f a) ≤ g ∧ ∀ (x : ι), x ∈ s → ↑v (f x) ≤ g
⊢ ↑v (∑ i in insert a s, f i) ≤ g

tactic: exact v.map_add_le hf.1 (ih hf.2)
state_before: K : Type ?u.625793
F : Type ?u.625796
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type ?u.625808
Γ''₀ : Type ?u.625811
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v : Valuation R Γ₀
x y z : R
ι : Type u_1
s✝ : Finset ι
f : ι → R
g : Γ₀
hf✝ : ∀ (i : ι), i ∈ s✝ → ↑v (f i) ≤ g
a : ι
s : Finset ι
has : ¬a ∈ s
ih : (∀ (i : ι), i ∈ s → ↑v (f i) ≤ g) → ↑v (∑ i in s, f i) ≤ g
hf : ↑v (f a) ≤ g ∧ ∀ (x : ι), x ∈ s → ↑v (f x) ≤ g
⊢ ↑v (f a + ∑ x in s, f x) ≤ g
Theorem: Sat.Valuation.mk_implies
File: Mathlib/Tactic/Sat/FromLRAT.lean

tactic: induction ps generalizing as₁ with
| nil => exact fun _ ↦ id
| cons a as ih =>
  refine fun e H ↦ @ih (a::as₁) e (H ?_)
  subst e; clear ih H
  suffices ∀ n n', n' = List.length as₁ + n →
    ∀ bs, mk (as₁.reverseAux bs) n' ↔ mk bs n from this 0 _ rfl (a::as)
  induction as₁ with simp
  | cons b as₁ ih => exact fun n bs ↦ ih (n+1) _ (Nat.succ_add ..) _
state_before: as ps : List Prop
p : Prop
as₁ : List Prop
⊢ as = List.reverseAux as₁ ps → implies (mk as) p ps (List.length as₁) → p

tactic: exact fun _ ↦ id
state_before: case nil
as : List Prop
p : Prop
as₁ : List Prop
⊢ as = List.reverseAux as₁ [] → implies (mk as) p [] (List.length as₁) → p

tactic: refine fun e H ↦ @ih (a::as₁) e (H ?_)
state_before: case cons
as✝ : List Prop
p a : Prop
as : List Prop
ih : ∀ (as₁ : List Prop), as✝ = List.reverseAux as₁ as → implies (mk as✝) p as (List.length as₁) → p
as₁ : List Prop
⊢ as✝ = List.reverseAux as₁ (a :: as) → implies (mk as✝) p (a :: as) (List.length as₁) → p

tactic: subst e
state_before: case cons
as✝ : List Prop
p a : Prop
as : List Prop
ih : ∀ (as₁ : List Prop), as✝ = List.reverseAux as₁ as → implies (mk as✝) p as (List.length as₁) → p
as₁ : List Prop
e : as✝ = List.reverseAux as₁ (a :: as)
H : implies (mk as✝) p (a :: as) (List.length as₁)
⊢ mk as✝ (List.length as₁) ↔ a

tactic: clear ih H
state_before: case cons
p a : Prop
as as₁ : List Prop
ih :
  ∀ (as₁_1 : List Prop),
    List.reverseAux as₁ (a :: as) = List.reverseAux as₁_1 as →
      implies (mk (List.reverseAux as₁ (a :: as))) p as (List.length as₁_1) → p
H : implies (mk (List.reverseAux as₁ (a :: as))) p (a :: as) (List.length as₁)
⊢ mk (List.reverseAux as₁ (a :: as)) (List.length as₁) ↔ a

tactic: suffices ∀ n n', n' = List.length as₁ + n →
  ∀ bs, mk (as₁.reverseAux bs) n' ↔ mk bs n from this 0 _ rfl (a::as)
state_before: case cons
p a : Prop
as as₁ : List Prop
⊢ mk (List.reverseAux as₁ (a :: as)) (List.length as₁) ↔ a

tactic: induction as₁ with simp
| cons b as₁ ih => exact fun n bs ↦ ih (n+1) _ (Nat.succ_add ..) _
state_before: case cons
p a : Prop
as as₁ : List Prop
⊢ ∀ (n n' : ℕ), n' = List.length as₁ + n → ∀ (bs : List Prop), mk (List.reverseAux as₁ bs) n' ↔ mk bs n

tactic: exact fun n bs ↦ ih (n+1) _ (Nat.succ_add ..) _
state_before: case cons.cons
p a : Prop
as : List Prop
b : Prop
as₁ : List Prop
ih : ∀ (n n' : ℕ), n' = List.length as₁ + n → ∀ (bs : List Prop), mk (List.reverseAux as₁ bs) n' ↔ mk bs n
⊢ ∀ (n : ℕ) (bs : List Prop), mk (List.reverseAux as₁ (b :: bs)) (Nat.succ (List.length as₁) + n) ↔ mk bs n
Theorem: Matrix.isHermitian_transpose_mul_self
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: rw [IsHermitian, conjTranspose_mul, conjTranspose_conjTranspose]
state_before: α : Type u_3
β : Type ?u.28730
m : Type u_1
n : Type u_2
A✝ : Matrix n n α
inst✝⁴ : NonUnitalSemiring α
inst✝³ : StarRing α
inst✝² : NonUnitalSemiring β
inst✝¹ : StarRing β
inst✝ : Fintype m
A : Matrix m n α
⊢ IsHermitian (Aᴴ ⬝ A)
Theorem: Finset.singleton_subset_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.35449
γ : Type ?u.35452
s : Finset α
a b : α
⊢ {a} ⊆ {b} ↔ a = b
Theorem: Cardinal.aleph0_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rcases lt_aleph0.1 hn with ⟨n, rfl⟩
state_before: α β : Type u
c : Cardinal
h : ∀ (n : ℕ), ↑n ≤ c
hn : c < ℵ₀
⊢ False

tactic: exact (Nat.lt_succ_self _).not_le (natCast_le.1 (h (n + 1)))
state_before: case intro
α β : Type u
n : ℕ
h : ∀ (n_1 : ℕ), ↑n_1 ≤ ↑n
hn : ↑n < ℵ₀
⊢ False
Theorem: Real.rpow_div_two_eq_sqrt
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [sqrt_eq_rpow, ← rpow_mul hx]
state_before: z x✝ y x r : ℝ
hx : 0 ≤ x
⊢ x ^ (r / 2) = sqrt x ^ r

tactic: congr
state_before: z x✝ y x r : ℝ
hx : 0 ≤ x
⊢ x ^ (r / 2) = x ^ (1 / 2 * r)

tactic: ring
state_before: case e_a
z x✝ y x r : ℝ
hx : 0 ≤ x
⊢ r / 2 = 1 / 2 * r
Theorem: Nat.Partrec.Code.const_prim
File: Mathlib/Computability/PartrecCode.lean

tactic: simp
state_before: n : ℕ
⊢ ((fun b => comp succ (n, b).snd)^[id n]) zero = Code.const n

tactic: induction n <;>
simp [*, Code.const, Function.iterate_succ', -Function.iterate_succ]
state_before: n : ℕ
⊢ ((fun b => comp succ b)^[n]) zero = Code.const n