tasksource/leandojo huggingface dataset:
Theorem: Nat.ord_compl_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: a b p : ℕ
⊢ a * b / p ^ ↑(factorization (a * b)) p = a / p ^ ↑(factorization a) p * (b / p ^ ↑(factorization b) p)

tactic: rcases eq_or_ne b 0 with (rfl | hb)
state_before: case inr
a b p : ℕ
ha : a ≠ 0
⊢ a * b / p ^ ↑(factorization (a * b)) p = a / p ^ ↑(factorization a) p * (b / p ^ ↑(factorization b) p)

tactic: simp only [ord_proj_mul p ha hb]
state_before: case inr.inr
a b p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a * b / p ^ ↑(factorization (a * b)) p = a / p ^ ↑(factorization a) p * (b / p ^ ↑(factorization b) p)

tactic: rw [mul_div_mul_comm_of_dvd_dvd (ord_proj_dvd a p) (ord_proj_dvd b p)]
state_before: case inr.inr
a b p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a * b / (p ^ ↑(factorization a) p * p ^ ↑(factorization b) p) =
    a / p ^ ↑(factorization a) p * (b / p ^ ↑(factorization b) p)

tactic: simp
state_before: case inl
b p : ℕ
⊢ 0 * b / p ^ ↑(factorization (0 * b)) p = 0 / p ^ ↑(factorization 0) p * (b / p ^ ↑(factorization b) p)

tactic: simp
state_before: case inr.inl
a p : ℕ
ha : a ≠ 0
⊢ a * 0 / p ^ ↑(factorization (a * 0)) p = a / p ^ ↑(factorization a) p * (0 / p ^ ↑(factorization 0) p)
Theorem: FormalMultilinearSeries.le_radius_of_eventually_le
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simpa
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.72515
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
C : ℝ
h : ∀ᶠ (n : ℕ) in atTop, ‖p n‖ * ↑r ^ n ≤ C
n : ℕ
hn : ‖p n‖ * ↑r ^ n ≤ C
⊢ ‖‖p n‖ * ↑r ^ n‖ ≤ C * ‖1‖
Theorem: Matrix.det_fin_three
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: simp [Matrix.det_succ_row_zero, Fin.sum_univ_succ]
state_before: m : Type ?u.2654416
n : Type ?u.2654419
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix (Fin 3) (Fin 3) R
⊢ det A =
    A 0 0 * A 1 1 * A 2 2 - A 0 0 * A 1 2 * A 2 1 - A 0 1 * A 1 0 * A 2 2 + A 0 1 * A 1 2 * A 2 0 +
        A 0 2 * A 1 0 * A 2 1 -
      A 0 2 * A 1 1 * A 2 0

tactic: ring
state_before: m : Type ?u.2654416
n : Type ?u.2654419
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix (Fin 3) (Fin 3) R
⊢ A 0 0 * (A 1 1 * A 2 2 + -(A 1 2 * A 2 1)) +
      (-(A 0 1 * (A 1 0 * A 2 2 + -(A 1 2 * A 2 0))) + (-1) ^ (1 + 1) * A 0 2 * (A 1 0 * A 2 1 + -(A 1 1 * A 2 0))) =
    A 0 0 * A 1 1 * A 2 2 - A 0 0 * A 1 2 * A 2 1 - A 0 1 * A 1 0 * A 2 2 + A 0 1 * A 1 2 * A 2 0 +
        A 0 2 * A 1 0 * A 2 1 -
      A 0 2 * A 1 1 * A 2 0
Theorem: Std.BinomialHeapImp.Heap.findMin_val
File: Std/Data/BinomialHeap.lean

tactic: rw [findMin, headD]
state_before: α : Type u_1
s✝ : Heap α
le : α → α → Bool
k : Heap α → Heap α
res : FindMin α
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ (findMin le k (cons r a c s) res).val = headD le res.val (cons r a c s)

tactic: split <;> apply findMin_val
state_before: α : Type u_1
s✝ : Heap α
le : α → α → Bool
k : Heap α → Heap α
res : FindMin α
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ (findMin le (k ∘ cons r a c) s
        (if le res.val a = true then res else { before := k, val := a, node := c, next := s })).val =
    headD le (if le res.val a = true then res.val else a) s
Theorem: nhds_translation_mul_inv₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simp
state_before: α : Type ?u.57877
β : Type ?u.57880
G₀ : Type u_1
inst✝² : TopologicalSpace G₀
inst✝¹ : GroupWithZero G₀
inst✝ : ContinuousMul G₀
a : G₀
ha : a ≠ 0
⊢ 𝓝 (↑(Homeomorph.symm (Homeomorph.symm (Homeomorph.mulRight₀ a ha))) 1) = 𝓝 a
Theorem: EuclideanGeometry.Sphere.secondInter_secondInter
File: Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean

tactic: by_cases hv : v = 0
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
⊢ secondInter s (secondInter s p v) v = p

tactic: have hv' : ⟪v, v⟫ ≠ 0 := inner_self_ne_zero.2 hv
state_before: case neg
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hv : ¬v = 0
⊢ secondInter s (secondInter s p v) v = p

tactic: simp only [Sphere.secondInter, vadd_vsub_assoc, vadd_vadd, inner_add_right, inner_smul_right,
  div_mul_cancel _ hv']
state_before: case neg
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hv : ¬v = 0
hv' : inner v v ≠ 0
⊢ secondInter s (secondInter s p v) v = p

tactic: rw [← @vsub_eq_zero_iff_eq V, vadd_vsub, ← add_smul, ← add_div]
state_before: case neg
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hv : ¬v = 0
hv' : inner v v ≠ 0
⊢ (-2 * (-2 * inner v (p -ᵥ s.center) + inner v (p -ᵥ s.center)) / inner v v) • v +
        (-2 * inner v (p -ᵥ s.center) / inner v v) • v +ᵥ
      p =
    p

tactic: convert zero_smul ℝ (M := V) _
state_before: case neg
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hv : ¬v = 0
hv' : inner v v ≠ 0
⊢ ((-2 * (-2 * inner v (p -ᵥ s.center) + inner v (p -ᵥ s.center)) + -2 * inner v (p -ᵥ s.center)) / inner v v) • v = 0

tactic: convert zero_div (G₀ := ℝ) _
state_before: case h.e'_2.h.e'_5
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hv : ¬v = 0
hv' : inner v v ≠ 0
⊢ (-2 * (-2 * inner v (p -ᵥ s.center) + inner v (p -ᵥ s.center)) + -2 * inner v (p -ᵥ s.center)) / inner v v = 0

tactic: ring
state_before: case h.e'_2.h.e'_5
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hv : ¬v = 0
hv' : inner v v ≠ 0
⊢ -2 * (-2 * inner v (p -ᵥ s.center) + inner v (p -ᵥ s.center)) + -2 * inner v (p -ᵥ s.center) = 0

tactic: simp [hv]
state_before: case pos
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
hv : v = 0
⊢ secondInter s (secondInter s p v) v = p
Theorem: MonoidAlgebra.mapDomain_one
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp_rw [one_def, mapDomain_single, map_one]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.399139
inst✝⁴ : Semiring k
α : Type u_1
β : Type u_2
α₂ : Type u_3
inst✝³ : Semiring β
inst✝² : One α
inst✝¹ : One α₂
F : Type u_4
inst✝ : OneHomClass F α α₂
f : F
⊢ mapDomain (↑f) 1 = 1
Theorem: HahnSeries.SummableFamily.one_sub_self_mul_hsum_powers
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rw [← hsum_smul, sub_smul 1 x (powers x hx), one_smul, hsum_sub, ←
  hsum_embDomain (x • powers x hx) ⟨Nat.succ, Nat.succ_injective⟩, embDomain_succ_smul_powers]
state_before: Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : CommRing R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < ↑(addVal Γ R) x
⊢ (1 - x) * hsum (powers x hx) = 1

tactic: simp
state_before: Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : CommRing R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < ↑(addVal Γ R) x
⊢ hsum (powers x hx) - hsum (powers x hx - ofFinsupp (Finsupp.single 0 1)) = 1
Theorem: MeasureTheory.L1.integral_sub
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.470478
𝕜 : Type ?u.470481
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f g : { x // x ∈ Lp E 1 }
⊢ integral (f - g) = integral f - integral g

tactic: exact map_sub integralCLM f g
state_before: α : Type u_1
E : Type u_2
F : Type ?u.470478
𝕜 : Type ?u.470481
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f g : { x // x ∈ Lp E 1 }
⊢ ↑integralCLM (f - g) = ↑integralCLM f - ↑integralCLM g
Theorem: inv_lt_iff_one_lt_mul'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_inv_self]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * a⁻¹ < a * b ↔ 1 < a * b
Theorem: Real.pi_gt_sqrtTwoAddSeries
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: have : sqrt (2 - sqrtTwoAddSeries 0 n) / (2 : ℝ) * (2 : ℝ) ^ (n + 2) < π := by
  rw [← lt_div_iff, ← sin_pi_over_two_pow_succ]; apply sin_lt; apply div_pos pi_pos
  all_goals apply pow_pos; norm_num
state_before: n : ℕ
⊢ 2 ^ (n + 1) * sqrt (2 - sqrtTwoAddSeries 0 n) < π

tactic: apply lt_of_le_of_lt (le_of_eq _) this
state_before: n : ℕ
this : sqrt (2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) < π
⊢ 2 ^ (n + 1) * sqrt (2 - sqrtTwoAddSeries 0 n) < π

tactic: rw [pow_succ _ (n + 1), ← mul_assoc, div_mul_cancel, mul_comm]
state_before: n : ℕ
this : sqrt (2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) < π
⊢ 2 ^ (n + 1) * sqrt (2 - sqrtTwoAddSeries 0 n) = sqrt (2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2)

tactic: norm_num
state_before: case h
n : ℕ
this : sqrt (2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) < π
⊢ 2 ≠ 0

tactic: rw [← lt_div_iff, ← sin_pi_over_two_pow_succ]
state_before: n : ℕ
⊢ sqrt (2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) < π

tactic: apply sin_lt
state_before: n : ℕ
⊢ sin (π / 2 ^ (n + 2)) < π / 2 ^ (n + 2)

n : ℕ
⊢ 0 < 2 ^ (n + 2)

tactic: apply div_pos pi_pos
state_before: case h
n : ℕ
⊢ 0 < π / 2 ^ (n + 2)

n : ℕ
⊢ 0 < 2 ^ (n + 2)

tactic: all_goals apply pow_pos; norm_num
state_before: case h
n : ℕ
⊢ 0 < 2 ^ (n + 2)

n : ℕ
⊢ 0 < 2 ^ (n + 2)

tactic: apply pow_pos
state_before: n : ℕ
⊢ 0 < 2 ^ (n + 2)

tactic: norm_num
state_before: case H
n : ℕ
⊢ 0 < 2
Theorem: FirstOrder.Language.BoundedFormula.imp_semanticallyEquivalent_not_sup
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp [imp_iff_not_or]
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ ψ : BoundedFormula L α n
M : Theory.ModelType T
v : α → ↑M
xs : Fin n → ↑M
⊢ Realize (φ ⟹ ψ ⇔ ∼φ ⊔ ψ) v xs
Theorem: Vector.get_map
File: Mathlib/Data/Vector/Basic.lean

tactic: cases v
state_before: n : ℕ
α : Type u_2
β : Type u_1
v : Vector α n
f : α → β
i : Fin n
⊢ get (map f v) i = f (get v i)

tactic: simp [Vector.map, get_eq_get]
state_before: case mk
n : ℕ
α : Type u_2
β : Type u_1
f : α → β
i : Fin n
val✝ : List α
property✝ : List.length val✝ = n
⊢ get (map f { val := val✝, property := property✝ }) i = f (get { val := val✝, property := property✝ } i)

tactic: rfl
state_before: case mk
n : ℕ
α : Type u_2
β : Type u_1
f : α → β
i : Fin n
val✝ : List α
property✝ : List.length val✝ = n
⊢ f (List.get val✝ { val := ↑i, isLt := (_ : ↑i < List.length val✝) }) =
    f (List.get val✝ (↑(Fin.cast (_ : n = List.length (toList { val := val✝, property := property✝ }))) i))
Theorem: MeasureTheory.NullMeasurableSet.exists_measurable_superset_ae_eq
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rcases h with ⟨t, htm, hst⟩
state_before: ι : Type ?u.5762
α : Type u_1
β : Type ?u.5768
γ : Type ?u.5771
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s

tactic: refine' ⟨t ∪ toMeasurable μ (s \ t), _, htm.union (measurableSet_toMeasurable _ _), _⟩
state_before: case intro.intro
ι : Type ?u.5762
α : Type u_1
β : Type ?u.5768
γ : Type ?u.5771
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s

tactic: exact diff_subset_iff.1 (subset_toMeasurable _ _)
state_before: case intro.intro.refine'_1
ι : Type ?u.5762
α : Type u_1
β : Type ?u.5768
γ : Type ?u.5771
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ t ∪ toMeasurable μ (s \ t) ⊇ s

tactic: have : toMeasurable μ (s \ t) =ᵐ[μ] (∅ : Set α) := by simp [ae_le_set.1 hst.le]
state_before: case intro.intro.refine'_2
ι : Type ?u.5762
α : Type u_1
β : Type ?u.5768
γ : Type ?u.5771
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ t ∪ toMeasurable μ (s \ t) =ᵐ[μ] s

tactic: simpa only [union_empty] using hst.symm.union this
state_before: case intro.intro.refine'_2
ι : Type ?u.5762
α : Type u_1
β : Type ?u.5768
γ : Type ?u.5771
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
this : toMeasurable μ (s \ t) =ᵐ[μ] ∅
⊢ t ∪ toMeasurable μ (s \ t) =ᵐ[μ] s

tactic: simp [ae_le_set.1 hst.le]
state_before: ι : Type ?u.5762
α : Type u_1
β : Type ?u.5768
γ : Type ?u.5771
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ toMeasurable μ (s \ t) =ᵐ[μ] ∅
Theorem: Polynomial.IsSplittingField.finiteDimensional
File: Mathlib/FieldTheory/SplittingField/IsSplittingField.lean

tactic: rw [hf, Polynomial.map_zero, roots_zero] at hy
state_before: F : Type u
K : Type v
L : Type w
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K L
f : K[X]
inst✝ : IsSplittingField K L f
y : L
hy : y ∈ ↑(Multiset.toFinset (roots (Polynomial.map (algebraMap K L) f)))
hf : f = 0
⊢ IsIntegral K y

tactic: cases hy
state_before: F : Type u
K : Type v
L : Type w
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K L
f : K[X]
inst✝ : IsSplittingField K L f
y : L
hy : y ∈ ↑(Multiset.toFinset 0)
hf : f = 0
⊢ IsIntegral K y
Theorem: Bool.or_and_distrib_right
File: Mathlib/Data/Bool/Basic.lean

tactic: cases a <;> cases b <;> cases c <;> simp
state_before: a b c : Bool
⊢ (a && b || c) = ((a || c) && (b || c))
Theorem: Polynomial.Irreducible.hasSeparableContraction
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: cases hF
state_before: F : Type u_1
inst✝ : Field F
q✝ : ℕ
f✝ : F[X]
hf : HasSeparableContraction q✝ f✝
q : ℕ
hF : ExpChar F q
f : F[X]
irred : Irreducible f
⊢ HasSeparableContraction q f

tactic: exact ⟨f, irred.separable, ⟨0, by rw [pow_zero, expand_one]⟩⟩
state_before: case zero
F : Type u_1
inst✝¹ : Field F
q : ℕ
f✝ : F[X]
hf : HasSeparableContraction q f✝
f : F[X]
irred : Irreducible f
inst✝ : CharZero F
⊢ HasSeparableContraction 1 f

tactic: rw [pow_zero, expand_one]
state_before: F : Type u_1
inst✝¹ : Field F
q : ℕ
f✝ : F[X]
hf : HasSeparableContraction q f✝
f : F[X]
irred : Irreducible f
inst✝ : CharZero F
⊢ ↑(expand F (1 ^ 0)) f = f

tactic: rcases exists_separable_of_irreducible q irred ‹q.Prime›.ne_zero with ⟨n, g, hgs, hge⟩
state_before: case prime
F : Type u_1
inst✝ : Field F
q✝ : ℕ
f✝ : F[X]
hf : HasSeparableContraction q✝ f✝
q : ℕ
f : F[X]
irred : Irreducible f
hprime✝ : Nat.Prime q
hchar✝ : CharP F q
⊢ HasSeparableContraction q f

tactic: exact ⟨g, hgs, n, hge⟩
state_before: case prime.intro.intro.intro
F : Type u_1
inst✝ : Field F
q✝ : ℕ
f✝ : F[X]
hf : HasSeparableContraction q✝ f✝
q : ℕ
f : F[X]
irred : Irreducible f
hprime✝ : Nat.Prime q
hchar✝ : CharP F q
n : ℕ
g : F[X]
hgs : Separable g
hge : ↑(expand F (q ^ n)) g = f
⊢ HasSeparableContraction q f
Theorem: Int.fract_zero
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [fract, floor_zero, cast_zero, sub_self]
state_before: F : Type ?u.157606
α : Type u_1
β : Type ?u.157612
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ fract 0 = 0
Theorem: Valued.mem_nhds_zero
File: Mathlib/Topology/Algebra/Valuation.lean

tactic: simp only [mem_nhds, sub_zero]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
s : Set R
⊢ s ∈ 𝓝 0 ↔ ∃ γ, {x | ↑v x < ↑γ} ⊆ s
Theorem: Finset.erase_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: simpa only [inter_comm t] using inter_erase a t s
state_before: α : Type u_1
β : Type ?u.261503
γ : Type ?u.261506
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ erase s a ∩ t = erase (s ∩ t) a
Theorem: Stream'.append_take_drop
File: Mathlib/Data/Stream/Init.lean

tactic: intro n
state_before: α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ) (s : Stream' α), take n s ++ₛ drop n s = s

tactic: induction' n with n' ih
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), take n s ++ₛ drop n s = s

tactic: intro s
state_before: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), take zero s ++ₛ drop zero s = s

tactic: rfl
state_before: case zero
α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ take zero s ++ₛ drop zero s = s

tactic: intro s
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), take n' s ++ₛ drop n' s = s
⊢ ∀ (s : Stream' α), take (succ n') s ++ₛ drop (succ n') s = s

tactic: rw [take_succ, drop_succ, cons_append_stream, ih (tail s), Stream'.eta]
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), take n' s ++ₛ drop n' s = s
s : Stream' α
⊢ take (succ n') s ++ₛ drop (succ n') s = s
Theorem: Matrix.col_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1212798
m : Type u_2
n : Type ?u.1212804
o : Type ?u.1212807
m' : o → Type ?u.1212812
n' : o → Type ?u.1212817
R : Type u_1
S : Type ?u.1212823
α : Type v
β : Type w
γ : Type ?u.1212830
inst✝ : SMul R α
x : R
v : m → α
⊢ col (x • v) = x • col v

tactic: rfl
state_before: case a.h
l : Type ?u.1212798
m : Type u_2
n : Type ?u.1212804
o : Type ?u.1212807
m' : o → Type ?u.1212812
n' : o → Type ?u.1212817
R : Type u_1
S : Type ?u.1212823
α : Type v
β : Type w
γ : Type ?u.1212830
inst✝ : SMul R α
x : R
v : m → α
i✝ : m
x✝ : Unit
⊢ col (x • v) i✝ x✝ = (x • col v) i✝ x✝
Theorem: UpperSet.compl_sInf
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_sInf, compl_iUnion₂, LowerSet.coe_iInf₂]
state_before: α : Type u_1
β : Type ?u.83182
γ : Type ?u.83185
ι : Sort ?u.83188
κ : ι → Sort ?u.83193
inst✝ : LE α
s t : UpperSet α
a : α
S : Set (UpperSet α)
⊢ ↑(compl (sInf S)) = ↑(⨅ (s : UpperSet α) (_ : s ∈ S), compl s)
Theorem: Asymptotics.isEquivalent_of_tendsto_one
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: rw [isEquivalent_iff_exists_eq_mul]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x = 0 → u x = 0
huv : Tendsto (u / v) l (𝓝 1)
⊢ u ~[l] v

tactic: refine' ⟨u / v, huv, hz.mono fun x hz' ↦ (div_mul_cancel_of_imp hz').symm⟩
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x = 0 → u x = 0
huv : Tendsto (u / v) l (𝓝 1)
⊢ ∃ φ x, u =ᶠ[l] φ * v
Theorem: Nat.floor_mono
File: Mathlib/Algebra/Order/Floor.lean

tactic: obtain ha | ha := le_total a 0
state_before: F : Type ?u.27586
α : Type u_1
β : Type ?u.27592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a ≤ b
⊢ ⌊a⌋₊ ≤ ⌊b⌋₊

tactic: rw [floor_of_nonpos ha]
state_before: case inl
F : Type ?u.27586
α : Type u_1
β : Type ?u.27592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a ≤ b
ha : a ≤ 0
⊢ ⌊a⌋₊ ≤ ⌊b⌋₊

tactic: exact Nat.zero_le _
state_before: case inl
F : Type ?u.27586
α : Type u_1
β : Type ?u.27592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a ≤ b
ha : a ≤ 0
⊢ 0 ≤ ⌊b⌋₊

tactic: exact le_floor ((floor_le ha).trans h)
state_before: case inr
F : Type ?u.27586
α : Type u_1
β : Type ?u.27592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a ≤ b
ha : 0 ≤ a
⊢ ⌊a⌋₊ ≤ ⌊b⌋₊
Theorem: Function.mulSupport_eq_iff
File: Mathlib/Algebra/Support.lean

tactic: simp (config := { contextual := true }) only [ext_iff, mem_mulSupport, ne_eq, iff_def,
  not_imp_comm, and_comm, forall_and]
state_before: α : Type u_1
β : Type ?u.1849
A : Type ?u.1852
B : Type ?u.1855
M : Type u_2
N : Type ?u.1861
P : Type ?u.1864
R : Type ?u.1867
S : Type ?u.1870
G : Type ?u.1873
M₀ : Type ?u.1876
G₀ : Type ?u.1879
ι : Sort ?u.1882
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
s : Set α
⊢ mulSupport f = s ↔ (∀ (x : α), x ∈ s → f x ≠ 1) ∧ ∀ (x : α), ¬x ∈ s → f x = 1
Theorem: CategoryTheory.Pretriangulated.comp_dist_triangle_mor_zero₃₁
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

tactic: have H₂ := rot_of_dist_triangle C T.rotate (rot_of_dist_triangle C T H)
state_before: C : Type u
inst✝⁹ : Category C
inst✝⁸ : HasZeroObject C
inst✝⁷ : HasShift C ℤ
inst✝⁶ : Preadditive C
inst✝⁵ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroObject D
inst✝² : HasShift D ℤ
inst✝¹ : Preadditive D
inst✝ : ∀ (n : ℤ), Functor.Additive (shiftFunctor D n)
hC : Pretriangulated C
T : Triangle C
H : T ∈ distinguishedTriangles
⊢ T.mor₃ ≫ (shiftEquiv C 1).functor.map T.mor₁ = 0

tactic: simpa using comp_dist_triangle_mor_zero₁₂ C T.rotate.rotate H₂
state_before: C : Type u
inst✝⁹ : Category C
inst✝⁸ : HasZeroObject C
inst✝⁷ : HasShift C ℤ
inst✝⁶ : Preadditive C
inst✝⁵ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroObject D
inst✝² : HasShift D ℤ
inst✝¹ : Preadditive D
inst✝ : ∀ (n : ℤ), Functor.Additive (shiftFunctor D n)
hC : Pretriangulated C
T : Triangle C
H : T ∈ distinguishedTriangles
H₂ : Triangle.rotate (Triangle.rotate T) ∈ distinguishedTriangles
⊢ T.mor₃ ≫ (shiftEquiv C 1).functor.map T.mor₁ = 0
Theorem: SimplicialObject.Splitting.ι_desc
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: dsimp only [ιSummand, desc]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Z : C
Δ : SimplexCategoryᵒᵖ
F : (A : IndexSet Δ) → N s (len A.fst.unop) ⟶ Z
A : IndexSet Δ
⊢ ιSummand s A ≫ desc s Δ F = F A

tactic: simp only [assoc, Iso.hom_inv_id_assoc, ιCoprod]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Z : C
Δ : SimplexCategoryᵒᵖ
F : (A : IndexSet Δ) → N s (len A.fst.unop) ⟶ Z
A : IndexSet Δ
⊢ (ιCoprod s.N A ≫ (iso s Δ).hom) ≫ (iso s Δ).inv ≫ Sigma.desc F = F A

tactic: erw [colimit.ι_desc, Cofan.mk_ι_app]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Z : C
Δ : SimplexCategoryᵒᵖ
F : (A : IndexSet Δ) → N s (len A.fst.unop) ⟶ Z
A : IndexSet Δ
⊢ Sigma.ι (summand s.N Δ) A ≫ Sigma.desc F = F A
Theorem: pow_eq_mod_card
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [pow_eq_mod_orderOf, ← Nat.mod_mod_of_dvd n orderOf_dvd_card_univ, ← pow_eq_mod_orderOf]
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Fintype G
n : ℕ
⊢ x ^ n = x ^ (n % Fintype.card G)
Theorem: Rat.toNNRat_pos
File: Mathlib/Data/Rat/NNRat.lean

tactic: simp [toNNRat, ← coe_lt_coe]
state_before: p q : ℚ
⊢ 0 < toNNRat q ↔ 0 < q
Theorem: Finset.erase_sdiff_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [erase_eq, sdiff_right_comm]
state_before: α : Type u_1
β : Type ?u.261878
γ : Type ?u.261881
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
⊢ erase s a \ t = erase (s \ t) a
Theorem: PowerSeries.coeff_zero_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff, Finsupp.single_zero, X, MvPowerSeries.coeff_zero_X]
state_before: R : Type u_1
inst✝ : Semiring R
⊢ ↑(coeff R 0) X = 0