tasksource/leandojo huggingface dataset:
Theorem: Polynomial.coeff_injective
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rintro ⟨p⟩ ⟨q⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ Injective coeff

tactic: simp only [coeff, FunLike.coe_fn_eq, imp_self, ofFinsupp.injEq]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
p q : AddMonoidAlgebra R ℕ
⊢ coeff { toFinsupp := p } = coeff { toFinsupp := q } → { toFinsupp := p } = { toFinsupp := q }
Theorem: Finsupp.subset_mapRange_neLocus
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: simpa only [mem_neLocus, mapRange_apply, not_imp_not] using congr_arg F
state_before: α : Type u_3
M : Type u_2
N : Type u_1
P : Type ?u.8114
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq N
inst✝² : Zero N
inst✝¹ : DecidableEq M
inst✝ : Zero M
f g : α →₀ N
F : N → M
F0 : F 0 = 0
x : α
⊢ x ∈ neLocus (mapRange F F0 f) (mapRange F F0 g) → x ∈ neLocus f g
Theorem: MeasureTheory.Measure.restrict_prod_eq_prod_univ
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: have : ν = ν.restrict Set.univ := Measure.restrict_univ.symm
state_before: α : Type u_1
α' : Type ?u.4488691
β : Type u_2
β' : Type ?u.4488697
γ : Type ?u.4488700
E : Type ?u.4488703
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set α
⊢ Measure.prod (restrict μ s) ν = restrict (Measure.prod μ ν) (s ×ˢ univ)

tactic: rw [this, Measure.prod_restrict, ← this]
state_before: α : Type u_1
α' : Type ?u.4488691
β : Type u_2
β' : Type ?u.4488697
γ : Type ?u.4488700
E : Type ?u.4488703
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set α
this : ν = restrict ν univ
⊢ Measure.prod (restrict μ s) ν = restrict (Measure.prod μ ν) (s ×ˢ univ)
Theorem: Primrec.dom_bool₂
File: Mathlib/Computability/Primrec.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
β : Type ?u.131924
γ : Type ?u.131927
δ : Type ?u.131930
σ : Type ?u.131933
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : Bool → Bool → α
x✝ : Bool × Bool
a b : Bool
⊢ (bif (a, b).fst then f true (a, b).snd else f false (a, b).snd) = f (a, b).fst (a, b).snd
Theorem: TopologicalSpace.Closeds.coe_iInf
File: Mathlib/Topology/Sets/Closeds.lean

tactic: ext
state_before: ι✝ : Type ?u.15394
α : Type u_2
β : Type ?u.15400
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_1
s : ι → Closeds α
⊢ ↑(⨅ (i : ι), s i) = ⋂ (i : ι), ↑(s i)

tactic: simp
state_before: case h
ι✝ : Type ?u.15394
α : Type u_2
β : Type ?u.15400
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_1
s : ι → Closeds α
x✝ : α
⊢ x✝ ∈ ↑(⨅ (i : ι), s i) ↔ x✝ ∈ ⋂ (i : ι), ↑(s i)
Theorem: List.countp_append
File: Mathlib/Data/List/Count.lean

tactic: simp only [countp_eq_length_filter, filter_append, length_append]
state_before: α : Type u_1
l : List α
p q : α → Bool
l₁ l₂ : List α
⊢ countp p (l₁ ++ l₂) = countp p l₁ + countp p l₂
Theorem: Matrix.det_updateColumn_add_self
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [← det_transpose, ← updateRow_transpose, ← det_transpose A]
state_before: m : Type ?u.1683272
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
⊢ det (updateColumn A i fun k => A k i + A k j) = det A

tactic: exact det_updateRow_add_self Aᵀ hij
state_before: m : Type ?u.1683272
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
⊢ det (updateRow Aᵀ i fun k => A k i + A k j) = det Aᵀ
Theorem: SemiconjBy.mul_right
File: Mathlib/Algebra/Group/Semiconj.lean

tactic: unfold SemiconjBy
state_before: S : Type u_1
inst✝ : Semigroup S
a b x y z x' y' : S
h : SemiconjBy a x y
h' : SemiconjBy a x' y'
⊢ SemiconjBy a (x * x') (y * y')

tactic: rw [←mul_assoc, h.eq, mul_assoc, h'.eq, ←mul_assoc]
state_before: S : Type u_1
inst✝ : Semigroup S
a b x y z x' y' : S
h : SemiconjBy a x y
h' : SemiconjBy a x' y'
⊢ a * (x * x') = y * y' * a
Theorem: Multiset.cons_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.10730
δ : Type ?u.10733
a : α
s t : Multiset α
f g : α → Multiset β
⊢ bind (a ::ₘ s) f = f a + bind s f
Theorem: Rat.le_def'
File: Mathlib/Data/Rat/Order.lean

tactic: rw [← @num_den q, ← @num_den p]
state_before: a b c p q : ℚ
⊢ p ≤ q ↔ p.num * ↑q.den ≤ q.num * ↑p.den

tactic: conv_rhs => simp only [num_den]
state_before: a b c p q : ℚ
⊢ p.num /. ↑p.den ≤ q.num /. ↑q.den ↔
    (p.num /. ↑p.den).num * ↑(q.num /. ↑q.den).den ≤ (q.num /. ↑q.den).num * ↑(p.num /. ↑p.den).den

tactic: exact Rat.le_def (by exact_mod_cast p.pos) (by exact_mod_cast q.pos)
state_before: a b c p q : ℚ
⊢ p.num /. ↑p.den ≤ q.num /. ↑q.den ↔ p.num * ↑q.den ≤ q.num * ↑p.den

tactic: exact_mod_cast p.pos
state_before: a b c p q : ℚ
⊢ 0 < ↑p.den

tactic: exact_mod_cast q.pos
state_before: a b c p q : ℚ
⊢ 0 < ↑q.den
Theorem: Nat.ModEq.gcd_eq
File: Mathlib/Data/Nat/ModEq.lean

tactic: have h1 := gcd_dvd_right a m
state_before: m n a b c d : ℕ
h : a ≡ b [MOD m]
⊢ gcd a m = gcd b m

tactic: have h2 := gcd_dvd_right b m
state_before: m n a b c d : ℕ
h : a ≡ b [MOD m]
h1 : gcd a m ∣ m
⊢ gcd a m = gcd b m

tactic: exact
  dvd_antisymm (dvd_gcd ((h.dvd_iff h1).mp (gcd_dvd_left a m)) h1)
    (dvd_gcd ((h.dvd_iff h2).mpr (gcd_dvd_left b m)) h2)
state_before: m n a b c d : ℕ
h : a ≡ b [MOD m]
h1 : gcd a m ∣ m
h2 : gcd b m ∣ m
⊢ gcd a m = gcd b m
Theorem: intervalIntegral.integral_eq_integral_of_support_subset
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: cases' le_total a b with hab hab
state_before: ι : Type ?u.16437814
𝕜 : Type ?u.16437817
E : Type u_1
F : Type ?u.16437823
A : Type ?u.16437826
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
h : support f ⊆ Ioc a b
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = ∫ (x : ℝ), f x ∂μ

tactic: rw [integral_of_le hab, ← integral_indicator measurableSet_Ioc, indicator_eq_self.2 h]
state_before: case inl
ι : Type ?u.16437814
𝕜 : Type ?u.16437817
E : Type u_1
F : Type ?u.16437823
A : Type ?u.16437826
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
h : support f ⊆ Ioc a b
hab : a ≤ b
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = ∫ (x : ℝ), f x ∂μ

tactic: rw [Ioc_eq_empty hab.not_lt, subset_empty_iff, support_eq_empty_iff] at h
state_before: case inr
ι : Type ?u.16437814
𝕜 : Type ?u.16437817
E : Type u_1
F : Type ?u.16437823
A : Type ?u.16437826
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
h : support f ⊆ Ioc a b
hab : b ≤ a
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = ∫ (x : ℝ), f x ∂μ

tactic: simp [h]
state_before: case inr
ι : Type ?u.16437814
𝕜 : Type ?u.16437817
E : Type u_1
F : Type ?u.16437823
A : Type ?u.16437826
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
h : f = 0
hab : b ≤ a
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = ∫ (x : ℝ), f x ∂μ
Theorem: SimpleGraph.Walk.length_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u' v' : V
p : Walk G u v
hu : u = u'
hv : v = v'
⊢ length (Walk.copy p hu hv) = length p

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' : V
p : Walk G u' v'
⊢ length (Walk.copy p (_ : u' = u') (_ : v' = v')) = length p
Theorem: ite_inter_closure_eq_of_inter_frontier_eq
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [closure_eq_self_union_frontier, inter_union_distrib_left, inter_union_distrib_left,
  ite_inter_self, ite_inter_of_inter_eq _ ht]
state_before: α : Type u_1
β : Type ?u.398357
γ : Type ?u.398360
δ : Type ?u.398363
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
s s' t : Set α
ht : s ∩ frontier t = s' ∩ frontier t
⊢ Set.ite t s s' ∩ closure t = s ∩ closure t
Theorem: CategoryTheory.Iso.homCongr_refl
File: Mathlib/CategoryTheory/Conj.lean

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y : C
f : X ⟶ Y
⊢ ↑(homCongr (refl X) (refl Y)) f = f
Theorem: Int.sub_mul
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.sub_eq_add_neg, Int.add_mul]
state_before: a b c : Int
⊢ (a - b) * c = a * c - b * c
Theorem: Nat.le_log_of_pow_le
File: Mathlib/Data/Nat/Log.lean

tactic: rcases ne_or_eq y 0 with (hy | rfl)
state_before: b x y : ℕ
hb : 1 < b
h : b ^ x ≤ y
⊢ x ≤ log b y

tactic: exacts [(pow_le_iff_le_log hb hy).1 h, (h.not_lt (pow_pos (zero_lt_one.trans hb) _)).elim]
state_before: case inl
b x y : ℕ
hb : 1 < b
h : b ^ x ≤ y
hy : y ≠ 0
⊢ x ≤ log b y

case inr
b x : ℕ
hb : 1 < b
h : b ^ x ≤ 0
⊢ x ≤ log b 0
Theorem: Finsupp.graph_zero
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp [graph]
state_before: α : Type u_1
β : Type ?u.5629
γ : Type ?u.5632
ι : Type ?u.5635
M : Type u_2
M' : Type ?u.5641
N : Type ?u.5644
P : Type ?u.5647
G : Type ?u.5650
H : Type ?u.5653
R : Type ?u.5656
S : Type ?u.5659
inst✝ : Zero M
⊢ graph 0 = ∅
Theorem: Pmf.map_comp
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp [map, Function.comp]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
f : α → β
p : Pmf α
b : β
g : β → γ
⊢ map g (map f p) = map (g ∘ f) p
Theorem: ULower.up_down
File: Mathlib/Logic/Encodable/Basic.lean

tactic: simp [up, down,Equiv.left_inv _ _, Equiv.symm_apply_apply]
state_before: α : Type u_1
inst✝ : Encodable α
a : α
⊢ up (down a) = a
Theorem: Metric.forall_of_forall_mem_ball
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: obtain ⟨R, hR, h⟩ : ∃ R > dist y x, ∀ z : α, z ∈ ball x R → p z :=
  frequently_iff.1 H (Ioi_mem_atTop (dist y x))
state_before: α : Type u
β : Type v
X : Type ?u.45910
ι : Type ?u.45913
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
p : α → Prop
x : α
H : ∃ᶠ (R : ℝ) in atTop, ∀ (y : α), y ∈ ball x R → p y
y : α
⊢ p y

tactic: exact h _ hR
state_before: case intro.intro
α : Type u
β : Type v
X : Type ?u.45910
ι : Type ?u.45913
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
p : α → Prop
x : α
H : ∃ᶠ (R : ℝ) in atTop, ∀ (y : α), y ∈ ball x R → p y
y : α
R : ℝ
hR : R > dist y x
h : ∀ (z : α), z ∈ ball x R → p z
⊢ p y
Theorem: CategoryTheory.Limits.colimit.ι_coconeMorphism
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasColimit F
c : Cocone F
j : J
⊢ ι F j ≫ (coconeMorphism c).Hom = c.ι.app j
Theorem: cast_bijective
File: Mathlib/Logic/Function/Basic.lean

tactic: cases h
state_before: α β : Sort u_1
h : α = β
⊢ Bijective (cast h)

tactic: refine ⟨fun _ _ ↦ id, fun x ↦ ⟨x, rfl⟩⟩
state_before: case refl
α : Sort u_1
⊢ Bijective (cast (_ : α = α))
Theorem: ContinuousLinearMap.norm_precompR_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: rw [one_mul]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.1605174
𝕜₃ : Type ?u.1605177
E : Type u_2
Eₗ : Type u_5
F : Type ?u.1605186
Fₗ : Type u_4
G : Type ?u.1605192
Gₗ : Type u_3
𝓕 : Type ?u.1605198
inst✝¹⁸ : SeminormedAddCommGroup E
inst✝¹⁷ : SeminormedAddCommGroup Eₗ
inst✝¹⁶ : SeminormedAddCommGroup F
inst✝¹⁵ : SeminormedAddCommGroup Fₗ
inst✝¹⁴ : SeminormedAddCommGroup G
inst✝¹³ : SeminormedAddCommGroup Gₗ
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : NontriviallyNormedField 𝕜₂
inst✝¹⁰ : NontriviallyNormedField 𝕜₃
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 Eₗ
inst✝⁷ : NormedSpace 𝕜₂ F
inst✝⁶ : NormedSpace 𝕜 Fₗ
inst✝⁵ : NormedSpace 𝕜₃ G
inst✝⁴ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomIsometric σ₂₃
inst✝¹ : RingHomIsometric σ₁₃
inst✝ : RingHomIsometric σ₁₂
L : E →L[𝕜] Fₗ →L[𝕜] Gₗ
⊢ 1 * ‖L‖ = ‖L‖
Theorem: essInf_const
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: rw [← ae_neBot] at hμ
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : ConditionallyCompleteLattice β
c : β
hμ : μ ≠ 0
⊢ essInf (fun x => c) μ = c

tactic: exact essInf_const' _
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : ConditionallyCompleteLattice β
c : β
hμ : NeBot (Measure.ae μ)
⊢ essInf (fun x => c) μ = c
Theorem: Finpartition.mem_avoid
File: Mathlib/Order/Partition/Finpartition.lean

tactic: simp only [avoid, ofErase, mem_erase, Ne.def, mem_image, exists_prop, ← exists_and_left,
  @and_left_comm (c ≠ ⊥)]
state_before: α : Type u_1
inst✝¹ : GeneralizedBooleanAlgebra α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
⊢ c ∈ (avoid P b).parts ↔ ∃ d, d ∈ P.parts ∧ ¬d ≤ b ∧ d \ b = c

tactic: refine' exists_congr fun d ↦ and_congr_right' <| and_congr_left _
state_before: α : Type u_1
inst✝¹ : GeneralizedBooleanAlgebra α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
⊢ (∃ x, x ∈ P.parts ∧ ¬c = ⊥ ∧ x \ b = c) ↔ ∃ d, d ∈ P.parts ∧ ¬d ≤ b ∧ d \ b = c

tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : GeneralizedBooleanAlgebra α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
d : α
⊢ d \ b = c → (¬c = ⊥ ↔ ¬d ≤ b)

tactic: rw [sdiff_eq_bot_iff]
state_before: α : Type u_1
inst✝¹ : GeneralizedBooleanAlgebra α
inst✝ : DecidableEq α
a b : α
P : Finpartition a
d : α
⊢ ¬d \ b = ⊥ ↔ ¬d ≤ b
Theorem: Nat.divisor_le
File: Mathlib/NumberTheory/Divisors.lean

tactic: cases' m with m
state_before: n m : ℕ
⊢ n ∈ divisors m → n ≤ m

tactic: simp
state_before: case zero
n : ℕ
⊢ n ∈ divisors zero → n ≤ zero

tactic: simp only [mem_divisors, Nat.succ_ne_zero m, and_true_iff, Ne.def, not_false_iff]
state_before: case succ
n m : ℕ
⊢ n ∈ divisors (succ m) → n ≤ succ m

tactic: exact Nat.le_of_dvd (Nat.succ_pos m)
state_before: case succ
n m : ℕ
⊢ n ∣ succ m → n ≤ succ m
Theorem: Finset.card_fin
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [Finset.card_univ, Fintype.card_fin]
state_before: α : Type ?u.10624
β : Type ?u.10627
γ : Type ?u.10630
n : ℕ
⊢ card univ = n
Theorem: MeasureTheory.Measure.restrict_restrict₀'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [restrict_apply hu, restrict_apply₀' ht, inter_assoc]
state_before: α : Type u_1
β : Type ?u.290469
γ : Type ?u.290472
δ : Type ?u.290475
ι : Type ?u.290478
R : Type ?u.290481
R' : Type ?u.290484
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
ht : NullMeasurableSet t
u : Set α
hu : MeasurableSet u
⊢ ↑↑(restrict (restrict μ t) s) u = ↑↑(restrict μ (s ∩ t)) u
Theorem: PosNum.pred'_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [pred'_to_nat n, Nat.succ_pred_eq_of_pos (to_nat_pos n)]
state_before: α : Type ?u.308729
n : PosNum
⊢ Nat.succ ↑(pred' n) = ↑n

tactic: rw [← to_nat_inj.1 h]
state_before: α : Type ?u.308729
n : PosNum
this : Nat.succ ↑(pred' n) = ↑n
h : ↑1 = ↑n
⊢ ↑(Num.casesOn 0 1 bit1) = Nat.pred (_root_.bit0 ↑n)

tactic: rfl
state_before: α : Type ?u.308729
n : PosNum
this : Nat.succ ↑(pred' n) = ↑n
h : ↑1 = ↑n
⊢ ↑(Num.casesOn 0 1 bit1) = Nat.pred (_root_.bit0 ↑1)

tactic: rw [← h]
state_before: α : Type ?u.308729
n : PosNum
this : Nat.succ ↑(pred' n) = ↑n
p : PosNum
h : Nat.succ ↑p = ↑n
⊢ ↑(Num.casesOn (pos p) 1 bit1) = Nat.pred (_root_.bit0 ↑n)

tactic: exact (Nat.succ_add p p).symm
state_before: α : Type ?u.308729
n : PosNum
this : Nat.succ ↑(pred' n) = ↑n
p : PosNum
h : Nat.succ ↑p = ↑n
⊢ ↑(Num.casesOn (pos p) 1 bit1) = Nat.pred (_root_.bit0 (Nat.succ ↑p))
Theorem: sup_sup_sup_comm
File: Mathlib/Order/Lattice.lean

tactic: rw [sup_assoc, sup_left_comm b, ← sup_assoc]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d✝ a b c d : α
⊢ a ⊔ b ⊔ (c ⊔ d) = a ⊔ c ⊔ (b ⊔ d)
Theorem: Matrix.inv_smul
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp [h, smul_smul]
state_before: l : Type ?u.285080
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
k : α
inst✝ : Invertible k
h : IsUnit (det A)
⊢ (⅟k • A⁻¹) ⬝ (k • A) = 1
Theorem: IsLocalizedModule.mk'_eq_mk'_iff
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: delta mk'
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.853060
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s₁ s₂ : { x // x ∈ S }
⊢ mk' f m₁ s₁ = mk' f m₂ s₂ ↔ ∃ s, s • s₁ • m₂ = s • s₂ • m₁

tactic: rw [(fromLocalizedModule.inj S f).eq_iff, LocalizedModule.mk_eq]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.853060
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s₁ s₂ : { x // x ∈ S }
⊢ ↑(fromLocalizedModule S f) (LocalizedModule.mk m₁ s₁) = ↑(fromLocalizedModule S f) (LocalizedModule.mk m₂ s₂) ↔
    ∃ s, s • s₁ • m₂ = s • s₂ • m₁

tactic: simp_rw [eq_comm]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.853060
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s₁ s₂ : { x // x ∈ S }
⊢ (∃ u, u • s₂ • m₁ = u • s₁ • m₂) ↔ ∃ s, s • s₁ • m₂ = s • s₂ • m₁
Theorem: gcd_mul_dvd_mul_gcd
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: obtain ⟨m', n', hm', hn', h⟩ := exists_dvd_and_dvd_of_dvd_mul (gcd_dvd_right k (m * n))
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n : α
⊢ gcd k (m * n) ∣ gcd k m * gcd k n

tactic: replace h : gcd k (m * n) = m' * n' := h
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
⊢ gcd k (m * n) ∣ gcd k m * gcd k n

tactic: rw [h]
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
⊢ gcd k (m * n) ∣ gcd k m * gcd k n

tactic: have hm'n' : m' * n' ∣ k := h ▸ gcd_dvd_left _ _
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
⊢ m' * n' ∣ gcd k m * gcd k n

tactic: apply mul_dvd_mul
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
hm'n' : m' * n' ∣ k
⊢ m' * n' ∣ gcd k m * gcd k n

tactic: have hm'k : m' ∣ k := (dvd_mul_right m' n').trans hm'n'
state_before: case intro.intro.intro.intro.a
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
hm'n' : m' * n' ∣ k
⊢ m' ∣ gcd k m

tactic: exact dvd_gcd hm'k hm'
state_before: case intro.intro.intro.intro.a
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
hm'n' : m' * n' ∣ k
hm'k : m' ∣ k
⊢ m' ∣ gcd k m

tactic: have hn'k : n' ∣ k := (dvd_mul_left n' m').trans hm'n'
state_before: case intro.intro.intro.intro.a
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
hm'n' : m' * n' ∣ k
⊢ n' ∣ gcd k n

tactic: exact dvd_gcd hn'k hn'
state_before: case intro.intro.intro.intro.a
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k m n m' n' : α
hm' : m' ∣ m
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
hm'n' : m' * n' ∣ k
hn'k : n' ∣ k
⊢ n' ∣ gcd k n
Theorem: Fin.cons_succ
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [cons]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (succ i)
i : Fin n
y : α (succ i)
z : α 0
⊢ cons x p (succ i) = p i
Theorem: Nat.Primrec'.unpair₂
File: Mathlib/Computability/Primrec.lean

tactic: have s := sqrt.comp₁ _ hf
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
⊢ Primrec' fun v => (unpair (f v)).snd

tactic: have fss := sub.comp₂ _ hf (mul.comp₂ _ s s)
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => Nat.sqrt (f v)
⊢ Primrec' fun v => (unpair (f v)).snd

tactic: refine' (if_lt fss s s (sub.comp₂ _ fss s)).of_eq fun v => _
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => Nat.sqrt (f v)
fss : Primrec' fun v => f v - Nat.sqrt (f v) * Nat.sqrt (f v)
⊢ Primrec' fun v => (unpair (f v)).snd

tactic: simp [Nat.unpair]
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => Nat.sqrt (f v)
fss : Primrec' fun v => f v - Nat.sqrt (f v) * Nat.sqrt (f v)
v : Vector ℕ n
⊢ (if f v - Nat.sqrt (f v) * Nat.sqrt (f v) < Nat.sqrt (f v) then Nat.sqrt (f v)
    else f v - Nat.sqrt (f v) * Nat.sqrt (f v) - Nat.sqrt (f v)) =
    (unpair (f v)).snd

tactic: split_ifs <;> rfl
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => Nat.sqrt (f v)
fss : Primrec' fun v => f v - Nat.sqrt (f v) * Nat.sqrt (f v)
v : Vector ℕ n
⊢ (if f v - Nat.sqrt (f v) * Nat.sqrt (f v) < Nat.sqrt (f v) then Nat.sqrt (f v)
    else f v - Nat.sqrt (f v) * Nat.sqrt (f v) - Nat.sqrt (f v)) =
    (if f v - Nat.sqrt (f v) * Nat.sqrt (f v) < Nat.sqrt (f v) then
        (f v - Nat.sqrt (f v) * Nat.sqrt (f v), Nat.sqrt (f v))
      else (Nat.sqrt (f v), f v - Nat.sqrt (f v) * Nat.sqrt (f v) - Nat.sqrt (f v))).snd
Theorem: Continuous.bounded_above_of_compact_support
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa [bddAbove_def] using hf.norm.bddAbove_range_of_hasCompactSupport h.norm
state_before: 𝓕 : Type ?u.1232898
𝕜 : Type ?u.1232901
α : Type u_1
ι : Type ?u.1232907
κ : Type ?u.1232910
E : Type u_2
F : Type ?u.1232916
G : Type ?u.1232919
inst✝¹ : NormedAddGroup E
inst✝ : TopologicalSpace α
f : α → E
hf : Continuous f
h : HasCompactSupport f
⊢ ∃ C, ∀ (x : α), ‖f x‖ ≤ C
Theorem: QuotientGroup.eq_iff_div_mem
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: refine' eq_comm.trans (QuotientGroup.eq.trans _)
state_before: G : Type u
inst✝¹ : Group G
N✝ : Subgroup G
nN✝ : Subgroup.Normal N✝
H : Type v
inst✝ : Group H
N : Subgroup G
nN : Subgroup.Normal N
x y : G
⊢ ↑x = ↑y ↔ x / y ∈ N

tactic: rw [nN.mem_comm_iff, div_eq_mul_inv]
state_before: G : Type u
inst✝¹ : Group G
N✝ : Subgroup G
nN✝ : Subgroup.Normal N✝
H : Type v
inst✝ : Group H
N : Subgroup G
nN : Subgroup.Normal N
x y : G
⊢ y⁻¹ * x ∈ N ↔ x / y ∈ N
Theorem: Real.Angle.two_zsmul_neg_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_zsmul, ← two_nsmul, two_nsmul_neg_pi_div_two]
state_before: ⊢ 2 • ↑(-π / 2) = ↑π