tasksource/leandojo huggingface dataset:
Theorem: AddLECancellable.lt_add_of_tsub_lt_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [lt_iff_le_and_ne, ← tsub_le_iff_right]
state_before: α : Type u_1
β : Type ?u.39404
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a < b + c

tactic: refine' ⟨h.le, _⟩
state_before: α : Type u_1
β : Type ?u.39404
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a - c ≤ b ∧ a ≠ b + c

tactic: rintro rfl
state_before: α : Type u_1
β : Type ?u.39404
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : a - c < b
⊢ a ≠ b + c

tactic: simp [hc] at h
state_before: α : Type u_1
β : Type ?u.39404
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
b c d : α
hc : AddLECancellable c
h : b + c - c < b
⊢ False
Theorem: Sym2.map_map
File: Mathlib/Data/Sym/Sym2.lean

tactic: revert x
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
g : β → γ
f : α → β
x : Sym2 α
⊢ map g (map f x) = map (g ∘ f) x

tactic: apply Sym2.ind
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
g : β → γ
f : α → β
⊢ ∀ (x : Sym2 α), map g (map f x) = map (g ∘ f) x

tactic: aesop
state_before: case h
α : Type u_1
β : Type u_3
γ : Type u_2
g : β → γ
f : α → β
⊢ ∀ (x y : α), map g (map f (Quotient.mk (Rel.setoid α) (x, y))) = map (g ∘ f) (Quotient.mk (Rel.setoid α) (x, y))
Theorem: Dfinsupp.erase_single_ne
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: rw [erase_single, if_neg h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ i j : ι
x : β i
h : i ≠ j
⊢ erase j (single i x) = single i x
Theorem: IsCoprime.sq_add_sq_ne_zero
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: intro h'
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a b : R
h : IsCoprime a b
⊢ a ^ 2 + b ^ 2 ≠ 0

tactic: obtain ⟨ha, hb⟩ := (add_eq_zero_iff'
(by rw [pow_two]; exact mul_self_nonneg _)
  (by rw [pow_two]; exact mul_self_nonneg _)).mp h'
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a b : R
h : IsCoprime a b
h' : a ^ 2 + b ^ 2 = 0
⊢ False

tactic: obtain rfl := pow_eq_zero ha
state_before: case intro
R : Type u_1
inst✝ : LinearOrderedCommRing R
a b : R
h : IsCoprime a b
h' : a ^ 2 + b ^ 2 = 0
ha : a ^ 2 = 0
hb : b ^ 2 = 0
⊢ False

tactic: obtain rfl := pow_eq_zero hb
state_before: case intro
R : Type u_1
inst✝ : LinearOrderedCommRing R
b : R
hb : b ^ 2 = 0
h : IsCoprime 0 b
h' : 0 ^ 2 + b ^ 2 = 0
ha : 0 ^ 2 = 0
⊢ False

tactic: exact not_isCoprime_zero_zero h
state_before: case intro
R : Type u_1
inst✝ : LinearOrderedCommRing R
ha hb : 0 ^ 2 = 0
h : IsCoprime 0 0
h' : 0 ^ 2 + 0 ^ 2 = 0
⊢ False

tactic: rw [pow_two]
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a b : R
h : IsCoprime a b
h' : a ^ 2 + b ^ 2 = 0
⊢ 0 ≤ a ^ 2

tactic: exact mul_self_nonneg _
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a b : R
h : IsCoprime a b
h' : a ^ 2 + b ^ 2 = 0
⊢ 0 ≤ a * a

tactic: rw [pow_two]
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a b : R
h : IsCoprime a b
h' : a ^ 2 + b ^ 2 = 0
⊢ 0 ≤ b ^ 2

tactic: exact mul_self_nonneg _
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a b : R
h : IsCoprime a b
h' : a ^ 2 + b ^ 2 = 0
⊢ 0 ≤ b * b
Theorem: CategoryTheory.eq_whisker
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: rw [w]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
f g : X ⟶ Y
w : f = g
h : Y ⟶ Z
⊢ f ≫ h = g ≫ h
Theorem: Finset.prod_ite
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp [prod_apply_ite _ _ fun x => x]
state_before: ι : Type ?u.398799
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
f g : α → β
⊢ (∏ x in s, if p x then f x else g x) = (∏ x in filter p s, f x) * ∏ x in filter (fun x => ¬p x) s, g x
Theorem: padicNormE.norm_int_lt_one_iff_dvd
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: constructor
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
⊢ ‖↑k‖ < 1 ↔ ↑p ∣ k

tactic: intro h
state_before: case mp
p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
⊢ ‖↑k‖ < 1 → ↑p ∣ k

tactic: contrapose! h
state_before: case mp
p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
h : ‖↑k‖ < 1
⊢ ↑p ∣ k

tactic: apply le_of_eq
state_before: case mp
p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
h : ¬↑p ∣ k
⊢ 1 ≤ ‖↑k‖

tactic: rw [eq_comm]
state_before: case mp.a
p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
h : ¬↑p ∣ k
⊢ 1 = ‖↑k‖

tactic: calc
  ‖(k : ℚ_[p])‖ = ‖((k : ℚ) : ℚ_[p])‖ := by norm_cast
  _ = padicNorm p k := (padicNormE.eq_padicNorm _)
  _ = 1 := by exact_mod_cast (int_eq_one_iff k).mpr h
state_before: case mp.a
p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
h : ¬↑p ∣ k
⊢ ‖↑k‖ = 1

tactic: norm_cast
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
h : ¬↑p ∣ k
⊢ ‖↑k‖ = ‖↑↑k‖

tactic: exact_mod_cast (int_eq_one_iff k).mpr h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
h : ¬↑p ∣ k
⊢ ↑(padicNorm p ↑k) = 1

tactic: rintro ⟨x, rfl⟩
state_before: case mpr
p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
⊢ ↑p ∣ k → ‖↑k‖ < 1

tactic: push_cast
state_before: case mpr.intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ
⊢ ‖↑(↑p * x)‖ < 1

tactic: rw [padicNormE.mul]
state_before: case mpr.intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ
⊢ ‖↑p * ↑x‖ < 1

tactic: calc
  _ ≤ ‖(p : ℚ_[p])‖ * 1 :=
    mul_le_mul le_rfl (by simpa using norm_int_le_one _) (norm_nonneg _) (norm_nonneg _)
  _ < 1 := by
    rw [mul_one, padicNormE.norm_p]
    apply inv_lt_one
    exact_mod_cast hp.1.one_lt
state_before: case mpr.intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ
⊢ ‖↑p‖ * ‖↑x‖ < 1

tactic: simpa using norm_int_le_one _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ
⊢ ‖↑x‖ ≤ 1

tactic: rw [mul_one, padicNormE.norm_p]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ
⊢ ‖↑p‖ * 1 < 1

tactic: apply inv_lt_one
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ
⊢ (↑p)⁻¹ < 1

tactic: exact_mod_cast hp.1.one_lt
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ
⊢ 1 < ↑p
Theorem: Cardinal.natCast_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_mk_fin, ← lift_mk_fin, lift_le, le_def, Function.Embedding.nonempty_iff_card_le,
  Fintype.card_fin, Fintype.card_fin]
state_before: α β : Type u
m n : ℕ
⊢ ↑m ≤ ↑n ↔ m ≤ n
Theorem: Algebraic.cardinal_mk_le_mul
File: Mathlib/Algebra/AlgebraicCard.lean

tactic: rw [← lift_id (#_), ← lift_id (#R[X])]
state_before: R A : Type u
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ (#{ x // IsAlgebraic R x }) ≤ (#R[X]) * ℵ₀

tactic: exact cardinal_mk_lift_le_mul R A
state_before: R A : Type u
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ lift (#{ x // IsAlgebraic R x }) ≤ lift (#R[X]) * ℵ₀
Theorem: IsUnit.mul_mul_div
File: Mathlib/Algebra/Hom/Units.lean

tactic: simp [h]
state_before: F : Type ?u.61273
G : Type ?u.61276
α : Type u_1
M : Type ?u.61282
N : Type ?u.61285
inst✝ : DivisionMonoid α
a✝ b c a : α
h : IsUnit b
⊢ a * b * (1 / b) = a
Theorem: exp_continuous
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: rw [continuous_iff_continuousOn_univ, ← Metric.eball_top_eq_univ (0 : 𝔸), ←
  expSeries_radius_eq_top 𝕂 𝔸]
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
𝔹 : Type ?u.357251
inst✝⁵ : IsROrC 𝕂
inst✝⁴ : NormedRing 𝔸
inst✝³ : NormedAlgebra 𝕂 𝔸
inst✝² : NormedRing 𝔹
inst✝¹ : NormedAlgebra 𝕂 𝔹
inst✝ : CompleteSpace 𝔸
⊢ Continuous (exp 𝕂)

tactic: exact continuousOn_exp
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
𝔹 : Type ?u.357251
inst✝⁵ : IsROrC 𝕂
inst✝⁴ : NormedRing 𝔸
inst✝³ : NormedAlgebra 𝕂 𝔸
inst✝² : NormedRing 𝔹
inst✝¹ : NormedAlgebra 𝕂 𝔹
inst✝ : CompleteSpace 𝔸
⊢ ContinuousOn (exp 𝕂) (EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸)))
Theorem: PosNum.succ_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp [add_left_comm]
state_before: α : Type ?u.23313
p : PosNum
⊢ ↑p + 1 + ↑p + 1 = ↑p + ↑p + 1 + 1
Theorem: Complex.abs_cpow_eq_rpow_re_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases hx.eq_or_lt with (rfl | hlt)
state_before: x : ℝ
hx : 0 ≤ x
y : ℂ
hy : y.re ≠ 0
⊢ ↑abs (↑x ^ y) = x ^ y.re

tactic: rw [ofReal_zero, zero_cpow, map_zero, Real.zero_rpow hy]
state_before: case inl
y : ℂ
hy : y.re ≠ 0
hx : 0 ≤ 0
⊢ ↑abs (↑0 ^ y) = 0 ^ y.re

tactic: exact ne_of_apply_ne re hy
state_before: case inl
y : ℂ
hy : y.re ≠ 0
hx : 0 ≤ 0
⊢ y ≠ 0

tactic: exact abs_cpow_eq_rpow_re_of_pos hlt y
state_before: case inr
x : ℝ
hx : 0 ≤ x
y : ℂ
hy : y.re ≠ 0
hlt : 0 < x
⊢ ↑abs (↑x ^ y) = x ^ y.re
Theorem: cauchySeq_iff_tendsto_dist_atTop_0
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [cauchySeq_iff_tendsto, Metric.uniformity_eq_comap_nhds_zero, tendsto_comap_iff]
state_before: α : Type u
β : Type v
X : Type ?u.213505
ι : Type ?u.213508
inst✝² : PseudoMetricSpace α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
⊢ CauchySeq u ↔ Tendsto (fun n => dist (u n.fst) (u n.snd)) atTop (𝓝 0)

tactic: rfl
state_before: α : Type u
β : Type v
X : Type ?u.213505
ι : Type ?u.213508
inst✝² : PseudoMetricSpace α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
⊢ Tendsto ((fun p => dist p.fst p.snd) ∘ Prod.map u u) atTop (𝓝 0) ↔
    Tendsto (fun n => dist (u n.fst) (u n.snd)) atTop (𝓝 0)
Theorem: Finset.diag_union
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨i, j⟩
state_before: α : Type u_1
β : Type ?u.123122
γ : Type ?u.123125
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ diag (s ∪ t) = diag s ∪ diag t

tactic: simp only [mem_diag, mem_union, or_and_right]
state_before: case a.mk
α : Type u_1
β : Type ?u.123122
γ : Type ?u.123125
inst✝ : DecidableEq α
s t : Finset α
x : α × α
i j : α
⊢ (i, j) ∈ diag (s ∪ t) ↔ (i, j) ∈ diag s ∪ diag t
Theorem: Multiset.erase_le_iff_le_cons
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← cons_erase m] at h
state_before: α : Type u_1
β : Type ?u.101950
γ : Type ?u.101953
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b : α
s t : Multiset α
a : α
h : s ≤ a ::ₘ t
m : a ∈ s
⊢ erase s a ≤ t

tactic: exact (cons_le_cons_iff _).1 h
state_before: α : Type u_1
β : Type ?u.101950
γ : Type ?u.101953
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b : α
s t : Multiset α
a : α
h : a ::ₘ erase s a ≤ a ::ₘ t
m : a ∈ s
⊢ erase s a ≤ t
Theorem: FirstOrder.Language.Substructure.realize_boundedFormula_top
File: Mathlib/ModelTheory/ElementaryMaps.lean

tactic: rw [← Substructure.topEquiv.realize_boundedFormula φ]
state_before: L : Language
M : Type u_4
N : Type ?u.369446
P : Type ?u.369449
Q : Type ?u.369452
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
inst✝ : Structure L Q
α : Type u_1
n : ℕ
φ : BoundedFormula L α n
v : α → { x // x ∈ ⊤ }
xs : Fin n → { x // x ∈ ⊤ }
⊢ BoundedFormula.Realize φ v xs ↔ BoundedFormula.Realize φ (Subtype.val ∘ v) (Subtype.val ∘ xs)

tactic: simp
state_before: L : Language
M : Type u_4
N : Type ?u.369446
P : Type ?u.369449
Q : Type ?u.369452
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
inst✝ : Structure L Q
α : Type u_1
n : ℕ
φ : BoundedFormula L α n
v : α → { x // x ∈ ⊤ }
xs : Fin n → { x // x ∈ ⊤ }
⊢ BoundedFormula.Realize φ (↑topEquiv ∘ v) (↑topEquiv ∘ xs) ↔
    BoundedFormula.Realize φ (Subtype.val ∘ v) (Subtype.val ∘ xs)
Theorem: iInf_univ
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.113928
γ : Type ?u.113931
ι : Sort ?u.113934
ι' : Sort ?u.113937
κ : ι → Sort ?u.113942
κ' : ι' → Sort ?u.113947
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
⊢ (⨅ (x : β) (_ : x ∈ univ), f x) = ⨅ (x : β), f x
Theorem: MeasureTheory.average_add_measure
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simp only [div_eq_inv_mul, mul_smul, measure_smul_average, ← smul_add, ←
  integral_add_measure hμ hν, ← ENNReal.toReal_add (measure_ne_top μ _) (measure_ne_top ν _)]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.201513
m0 : MeasurableSpace α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : CompleteSpace E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
μ : Measure α
s : Set E
inst✝¹ : IsFiniteMeasure μ
ν : Measure α
inst✝ : IsFiniteMeasure ν
f : α → E
hμ : Integrable f
hν : Integrable f
⊢ (⨍ (x : α), f x ∂μ + ν) =
    ((ENNReal.toReal (↑↑μ univ) / (ENNReal.toReal (↑↑μ univ) + ENNReal.toReal (↑↑ν univ))) • ⨍ (x : α), f x ∂μ) +
      (ENNReal.toReal (↑↑ν univ) / (ENNReal.toReal (↑↑μ univ) + ENNReal.toReal (↑↑ν univ))) • ⨍ (x : α), f x ∂ν

tactic: rw [average_eq, Measure.add_apply]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.201513
m0 : MeasurableSpace α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : CompleteSpace E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
μ : Measure α
s : Set E
inst✝¹ : IsFiniteMeasure μ
ν : Measure α
inst✝ : IsFiniteMeasure ν
f : α → E
hμ : Integrable f
hν : Integrable f
⊢ (⨍ (x : α), f x ∂μ + ν) = (ENNReal.toReal (↑↑μ univ + ↑↑ν univ))⁻¹ • ∫ (x : α), f x ∂μ + ν
Theorem: Finset.zero_smul_subset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [subset_iff, mem_smul]
state_before: F : Type ?u.911536
α : Type u_2
β : Type u_1
γ : Type ?u.911545
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
inst✝ : DecidableEq β
s : Finset α
t✝ t : Finset β
⊢ 0 • t ⊆ 0
Theorem: LieAlgebra.isLieAbelian_bot
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: simp
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝¹ x✝ : { x // x ∈ ↑⊥ }
x : L
hx : x ∈ ↑⊥
⊢ ⁅{ val := x, property := hx }, x✝⁆ = 0
Theorem: CompositionSeries.eraseTop_top_le
File: Mathlib/Order/JordanHolder.lean

tactic: simp [eraseTop, top, s.strictMono.le_iff_le, Fin.le_iff_val_le_val, tsub_le_self]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ top (eraseTop s) ≤ top s
Theorem: PGame.leftMoves_add_cases
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← toLeftMovesAdd.apply_symm_apply k]
state_before: x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (↑toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (↑toLeftMovesAdd (Sum.inr i))
⊢ P k

tactic: cases' toLeftMovesAdd.symm k with i i
state_before: x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (↑toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (↑toLeftMovesAdd (Sum.inr i))
⊢ P (↑toLeftMovesAdd (↑toLeftMovesAdd.symm k))

tactic: exact hl i
state_before: case inl
x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (↑toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (↑toLeftMovesAdd (Sum.inr i))
i : LeftMoves x
⊢ P (↑toLeftMovesAdd (Sum.inl i))

tactic: exact hr i
state_before: case inr
x y : PGame
k : LeftMoves (x + y)
P : LeftMoves (x + y) → Prop
hl : ∀ (i : LeftMoves x), P (↑toLeftMovesAdd (Sum.inl i))
hr : ∀ (i : LeftMoves y), P (↑toLeftMovesAdd (Sum.inr i))
i : LeftMoves y
⊢ P (↑toLeftMovesAdd (Sum.inr i))
Theorem: Submodule.fst_map_snd
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [eq_bot_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.342129
M₆ : Type ?u.342132
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (snd R M M₂) (fst R M M₂) = ⊥

tactic: intro x
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.342129
M₆ : Type ?u.342132
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (snd R M M₂) (fst R M M₂) ≤ ⊥

tactic: simp only [fst, comap_bot, mem_map, mem_ker, snd_apply, eq_comm, Prod.exists, exists_eq_left,
  exists_const, mem_bot, imp_self]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.342129
M₆ : Type ?u.342132
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (snd R M M₂) (fst R M M₂) → x ∈ ⊥
Theorem: List.ofFn_mul'
File: Mathlib/Data/List/OfFn.lean

tactic: simp_rw [mul_comm m n, mul_comm m, ofFn_mul, Fin.cast_mk]
state_before: α : Type u
m n : ℕ
f : Fin (m * n) → α
⊢ ofFn f = join (ofFn fun i => ofFn fun j => f { val := m * ↑i + ↑j, isLt := (_ : m * ↑i + ↑j < m * n) })
Theorem: Metric.ball_subset_thickening
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [Subset.rfl]
state_before: ι : Sort ?u.96623
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
x : X
E : Set X
hx : x ∈ E
δ : ℝ
⊢ ball x δ ⊆ thickening δ {x}
Theorem: OrderHom.coe_iInf
File: Mathlib/Order/Hom/Order.lean

tactic: funext x
state_before: α : Type u_3
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_1
inst✝ : CompleteLattice β
f : ι → α →o β
⊢ ↑(⨅ (i : ι), f i) = ⨅ (i : ι), ↑(f i)

tactic: simp [iInf_apply]
state_before: case h
α : Type u_3
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_1
inst✝ : CompleteLattice β
f : ι → α →o β
x : α
⊢ ↑(⨅ (i : ι), f i) x = iInf (fun i => ↑(f i)) x
Theorem: PiTensorProduct.liftAux_tprod
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

tactic: simp only [liftAux, liftAddHom, tprod_eq_tprodCoeff_one, tprodCoeff, AddCon.coe_mk']
state_before: ι : Type u_4
ι₂ : Type ?u.250369
ι₃ : Type ?u.250372
R : Type u_1
inst✝⁷ : CommSemiring R
R₁ : Type ?u.250381
R₂ : Type ?u.250384
s : ι → Type u_2
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type ?u.250574
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_3
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type ?u.250842
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
f : (i : ι) → s i
⊢ ↑(liftAux φ) (↑(tprod R) f) = ↑φ f

tactic: rw [FreeAddMonoid.of, FreeAddMonoid.ofList, Equiv.refl_apply, AddCon.lift_coe]
state_before: ι : Type u_4
ι₂ : Type ?u.250369
ι₃ : Type ?u.250372
R : Type u_1
inst✝⁷ : CommSemiring R
R₁ : Type ?u.250381
R₂ : Type ?u.250384
s : ι → Type u_2
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type ?u.250574
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_3
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type ?u.250842
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
f : (i : ι) → s i
⊢ ↑(AddCon.lift (addConGen (Eqv R fun i => s i)) (↑FreeAddMonoid.lift fun p => p.fst • ↑φ p.snd)
          (_ : addConGen (Eqv R fun i => s i) ≤ AddCon.ker (↑FreeAddMonoid.lift fun p => p.fst • ↑φ p.snd)))
      ↑(FreeAddMonoid.of (1, f)) =
    ↑φ f

tactic: dsimp [FreeAddMonoid.lift, FreeAddMonoid.sumAux]
state_before: ι : Type u_4
ι₂ : Type ?u.250369
ι₃ : Type ?u.250372
R : Type u_1
inst✝⁷ : CommSemiring R
R₁ : Type ?u.250381
R₂ : Type ?u.250384
s : ι → Type u_2
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type ?u.250574
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_3
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type ?u.250842
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
f : (i : ι) → s i
⊢ ↑(↑FreeAddMonoid.lift fun p => p.fst • ↑φ p.snd) [(1, f)] = ↑φ f

tactic: show _ • _ = _
state_before: ι : Type u_4
ι₂ : Type ?u.250369
ι₃ : Type ?u.250372
R : Type u_1
inst✝⁷ : CommSemiring R
R₁ : Type ?u.250381
R₂ : Type ?u.250384
s : ι → Type u_2
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type ?u.250574
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_3
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type ?u.250842
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
f : (i : ι) → s i
⊢ (FreeAddMonoid.sumAux.match_1 (fun x => E) [1 • ↑φ f] (fun _ => 0) fun x xs =>
      List.foldl (fun x x_1 => x + x_1) x xs) =
    ↑φ f

tactic: rw [one_smul]
state_before: ι : Type u_4
ι₂ : Type ?u.250369
ι₃ : Type ?u.250372
R : Type u_1
inst✝⁷ : CommSemiring R
R₁ : Type ?u.250381
R₂ : Type ?u.250384
s : ι → Type u_2
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type ?u.250574
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_3
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type ?u.250842
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
f : (i : ι) → s i
⊢ 1 • ↑φ f = ↑φ f
Theorem: Composition.sizeUpTo_le
File: Mathlib/Combinatorics/Composition.lean

tactic: conv_rhs => rw [← c.blocks_sum, ← sum_take_add_sum_drop _ i]
state_before: n : ℕ
c : Composition n
i : ℕ
⊢ sizeUpTo c i ≤ n

tactic: exact Nat.le_add_right _ _
state_before: n : ℕ
c : Composition n
i : ℕ
⊢ sizeUpTo c i ≤ sum (take i c.blocks) + sum (drop i c.blocks)
Theorem: SeminormFamily.basisSets_singleton_mem
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [Finset.sup_singleton]
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.15394
𝕝 : Type ?u.15397
𝕝₂ : Type ?u.15400
E : Type u_1
F : Type ?u.15406
G : Type ?u.15409
ι : Type u_3
ι' : Type ?u.15415
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
i : ι
r : ℝ
hr : 0 < r
⊢ ball (p i) 0 r = ball (Finset.sup {i} p) 0 r
Theorem: circleMap_mem_sphere
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simpa only [_root_.abs_of_nonneg hR] using circleMap_mem_sphere' c R θ
state_before: E : Type ?u.10653
inst✝ : NormedAddCommGroup E
c : ℂ
R : ℝ
hR : 0 ≤ R
θ : ℝ
⊢ circleMap c R θ ∈ sphere c R
Theorem: Finsupp.support_single_ne_bot
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simpa only [support_single_ne_zero _ h] using singleton_ne_empty _
state_before: α : Type u_2
β : Type ?u.57814
γ : Type ?u.57817
ι : Type ?u.57820
M : Type u_1
M' : Type ?u.57826
N : Type ?u.57829
P : Type ?u.57832
G : Type ?u.57835
H : Type ?u.57838
R : Type ?u.57841
S : Type ?u.57844
inst✝ : Zero M
a a' : α
b : M
i : α
h : b ≠ 0
⊢ (single i b).support ≠ ⊥
Theorem: Substring.Valid.data_dropWhile
File: Std/Data/String/Lemmas.lean

tactic: simp [(h.dropWhile _).toString, h.toString]
state_before: p : Char → Bool
x✝ : Substring
h✝ : Valid x✝
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ (toString (Substring.dropWhile x✝ p)).data = List.dropWhile p (toString x✝).data
Theorem: Orthonormal.inner_sum
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp_rw [sum_inner, inner_smul_left]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2093366
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l₁ l₂ : ι → 𝕜
s : Finset ι
⊢ inner (∑ i in s, l₁ i • v i) (∑ i in s, l₂ i • v i) = ∑ i in s, ↑(starRingEnd 𝕜) (l₁ i) * l₂ i

tactic: refine' Finset.sum_congr rfl fun i hi => _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2093366
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l₁ l₂ : ι → 𝕜
s : Finset ι
⊢ ∑ x in s, ↑(starRingEnd 𝕜) (l₁ x) * inner (v x) (∑ i in s, l₂ i • v i) = ∑ x in s, ↑(starRingEnd 𝕜) (l₁ x) * l₂ x

tactic: rw [hv.inner_right_sum l₂ hi]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2093366
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l₁ l₂ : ι → 𝕜
s : Finset ι
i : ι
hi : i ∈ s
⊢ ↑(starRingEnd 𝕜) (l₁ i) * inner (v i) (∑ i in s, l₂ i • v i) = ↑(starRingEnd 𝕜) (l₁ i) * l₂ i
Theorem: Polynomial.trinomial_leadingCoeff
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: rw [leadingCoeff, trinomial_natDegree hkm hmn hw, trinomial_leading_coeff' hkm hmn]
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
hw : w ≠ 0
⊢ leadingCoeff (trinomial k m n u v w) = w