tasksource/leandojo huggingface dataset:
Theorem: IsCoprime.mul_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: ring
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x z
H2 : IsCoprime y z
a b : R
h1 : a * x + b * z = 1
c d : R
h2 : c * y + d * z = 1
⊢ a * c * (x * y) + (a * x * d + b * c * y + b * d * z) * z = (a * x + b * z) * (c * y + d * z)

tactic: rw [h1, h2, mul_one]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x z
H2 : IsCoprime y z
a b : R
h1 : a * x + b * z = 1
c d : R
h2 : c * y + d * z = 1
⊢ (a * x + b * z) * (c * y + d * z) = 1
Theorem: Mathlib.Tactic.Abel.const_add_termg
File: Mathlib/Tactic/Abel.lean

tactic: simp [h.symm, termg, add_comm, add_assoc]
state_before: α : Type u_1
inst✝ : AddCommGroup α
k : α
n : ℤ
x a a' : α
h : k + a = a'
⊢ k + termg n x a = termg n x a'
Theorem: inv_mul_lt_iff'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [inv_mul_lt_iff h, mul_comm]
state_before: ι : Type ?u.36563
α : Type u_1
β : Type ?u.36569
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ b⁻¹ * a < c ↔ a < c * b
Theorem: Matrix.zpow_mul
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_ofNat, zpow_ofNat, ← pow_mul, ← zpow_ofNat, Int.ofNat_mul]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
m n : ℕ
⊢ A ^ (↑m * ↑n) = (A ^ ↑m) ^ ↑n

tactic: rw [zpow_ofNat, zpow_negSucc, ← pow_mul, ofNat_mul_negSucc, zpow_neg_coe_nat]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
m n : ℕ
⊢ A ^ (↑m * -[n+1]) = (A ^ ↑m) ^ -[n+1]

tactic: rw [zpow_ofNat, zpow_negSucc, ← inv_pow', ← pow_mul, negSucc_mul_ofNat, zpow_neg_coe_nat,
    inv_pow']
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
m n : ℕ
⊢ A ^ (-[m+1] * ↑n) = (A ^ -[m+1]) ^ ↑n

tactic: rw [zpow_negSucc, zpow_negSucc, negSucc_mul_negSucc, ← Int.ofNat_mul, zpow_ofNat, inv_pow', ←
  pow_mul, nonsing_inv_nonsing_inv]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
m n : ℕ
⊢ A ^ (-[m+1] * -[n+1]) = (A ^ -[m+1]) ^ -[n+1]

tactic: rw [det_pow]
state_before: case h
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
m n : ℕ
⊢ IsUnit (det (A ^ ((m + 1) * (n + 1))))

tactic: exact h.pow _
state_before: case h
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
m n : ℕ
⊢ IsUnit (det A ^ ((m + 1) * (n + 1)))
Theorem: Complex.countable_preimage_exp
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: refine' ⟨fun hs => _, fun hs => _⟩
state_before: s : Set ℂ
⊢ Set.Countable (exp ⁻¹' s) ↔ Set.Countable s

tactic: refine' ((hs.image exp).insert 0).mono _
state_before: case refine'_1
s : Set ℂ
hs : Set.Countable (exp ⁻¹' s)
⊢ Set.Countable s

tactic: rw [Set.image_preimage_eq_inter_range, range_exp, ←Set.diff_eq, ←Set.union_singleton,
    Set.diff_union_self]
state_before: case refine'_1
s : Set ℂ
hs : Set.Countable (exp ⁻¹' s)
⊢ s ⊆ insert 0 (exp '' (exp ⁻¹' s))

tactic: exact Set.subset_union_left _ _
state_before: case refine'_1
s : Set ℂ
hs : Set.Countable (exp ⁻¹' s)
⊢ s ⊆ s ∪ {0}

tactic: rw [← Set.biUnion_preimage_singleton]
state_before: case refine'_2
s : Set ℂ
hs : Set.Countable s
⊢ Set.Countable (exp ⁻¹' s)

tactic: refine' hs.biUnion fun z hz => _
state_before: case refine'_2
s : Set ℂ
hs : Set.Countable s
⊢ Set.Countable (⋃ (y : ℂ) (_ : y ∈ s), exp ⁻¹' {y})

tactic: rcases em (∃ w, exp w = z) with (⟨w, rfl⟩ | hne)
state_before: case refine'_2
s : Set ℂ
hs : Set.Countable s
z : ℂ
hz : z ∈ s
⊢ Set.Countable (exp ⁻¹' {z})

tactic: simp only [Set.preimage, Set.mem_singleton_iff, exp_eq_exp_iff_exists_int, Set.setOf_exists]
state_before: case refine'_2.inl.intro
s : Set ℂ
hs : Set.Countable s
w : ℂ
hz : exp w ∈ s
⊢ Set.Countable (exp ⁻¹' {exp w})

tactic: exact Set.countable_iUnion fun m => Set.countable_singleton _
state_before: case refine'_2.inl.intro
s : Set ℂ
hs : Set.Countable s
w : ℂ
hz : exp w ∈ s
⊢ Set.Countable (⋃ (i : ℤ), {x | x = w + ↑i * (2 * ↑π * I)})

tactic: push_neg  at hne
state_before: case refine'_2.inr
s : Set ℂ
hs : Set.Countable s
z : ℂ
hz : z ∈ s
hne : ¬∃ w, exp w = z
⊢ Set.Countable (exp ⁻¹' {z})

tactic: simp [Set.preimage, hne]
state_before: case refine'_2.inr
s : Set ℂ
hs : Set.Countable s
z : ℂ
hz : z ∈ s
hne : ∀ (w : ℂ), exp w ≠ z
⊢ Set.Countable (exp ⁻¹' {z})
Theorem: zero_le'
File: Mathlib/Algebra/Order/WithZero.lean

tactic: simpa only [mul_zero, mul_one] using mul_le_mul_left' zero_le_one a
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommMonoidWithZero α
⊢ 0 ≤ a
Theorem: Set.union_iInter₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [union_iInter]
state_before: α : Type u_1
β : Type ?u.116945
γ : Type ?u.116948
ι : Sort u_2
ι' : Sort ?u.116954
ι₂ : Sort ?u.116957
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.116967
κ₂ : ι → Sort ?u.116972
κ' : ι' → Sort ?u.116977
s : Set α
t : (i : ι) → κ i → Set α
⊢ (s ∪ ⋂ (i : ι) (j : κ i), t i j) = ⋂ (i : ι) (j : κ i), s ∪ t i j
Theorem: Module.DualBases.mem_of_mem_span
File: Mathlib/LinearAlgebra/Dual.lean

tactic: intro i hi
state_before: R : Type u_3
M : Type u_2
ι : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
x : M
hmem : x ∈ Submodule.span R (e '' H)
⊢ ∀ (i : ι), ↑(ε i) x ≠ 0 → i ∈ H

tactic: rcases(Finsupp.mem_span_image_iff_total _).mp hmem with ⟨l, supp_l, rfl⟩
state_before: R : Type u_3
M : Type u_2
ι : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
x : M
hmem : x ∈ Submodule.span R (e '' H)
i : ι
hi : ↑(ε i) x ≠ 0
⊢ i ∈ H

tactic: apply not_imp_comm.mp ((Finsupp.mem_supported' _ _).mp supp_l i)
state_before: case intro.intro
R : Type u_3
M : Type u_2
ι : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
i : ι
l : ι →₀ R
supp_l : l ∈ Finsupp.supported R R H
hmem : ↑(Finsupp.total ι M R e) l ∈ Submodule.span R (e '' H)
hi : ↑(ε i) (↑(Finsupp.total ι M R e) l) ≠ 0
⊢ i ∈ H

tactic: rwa [← lc_def, h.dual_lc] at hi
state_before: case intro.intro
R : Type u_3
M : Type u_2
ι : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
i : ι
l : ι →₀ R
supp_l : l ∈ Finsupp.supported R R H
hmem : ↑(Finsupp.total ι M R e) l ∈ Submodule.span R (e '' H)
hi : ↑(ε i) (↑(Finsupp.total ι M R e) l) ≠ 0
⊢ ¬↑l i = 0
Theorem: MeasureTheory.snorm_neg
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: by_cases h0 : p = 0
state_before: α : Type u_1
E : Type ?u.3178601
F : Type u_2
G : Type ?u.3178607
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snorm (-f) p μ = snorm f p μ

tactic: by_cases h_top : p = ∞
state_before: case neg
α : Type u_1
E : Type ?u.3178601
F : Type u_2
G : Type ?u.3178607
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
⊢ snorm (-f) p μ = snorm f p μ

tactic: simp [snorm_eq_snorm' h0 h_top]
state_before: case neg
α : Type u_1
E : Type ?u.3178601
F : Type u_2
G : Type ?u.3178607
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
h_top : ¬p = ⊤
⊢ snorm (-f) p μ = snorm f p μ

tactic: simp [h0]
state_before: case pos
α : Type u_1
E : Type ?u.3178601
F : Type u_2
G : Type ?u.3178607
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : p = 0
⊢ snorm (-f) p μ = snorm f p μ

tactic: simp [h_top, snormEssSup]
state_before: case pos
α : Type u_1
E : Type ?u.3178601
F : Type u_2
G : Type ?u.3178607
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
h_top : p = ⊤
⊢ snorm (-f) p μ = snorm f p μ
Theorem: Int.cast_one
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: erw [cast_ofNat, Nat.cast_one]
state_before: R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑1 = 1
Theorem: OrderIso.image_Ico
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: rw [e.image_eq_preimage, e.symm.preimage_Ico, e.symm_symm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a b : α
⊢ ↑e '' Ico a b = Ico (↑e a) (↑e b)
Theorem: ENNReal.dichotomy
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa using ENNReal.trichotomy₂ (Fact.out : 1 ≤ p)
state_before: α : Type ?u.832980
β : Type ?u.832983
a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
⊢ p = ⊤ ∨ 0 < ENNReal.toReal p ∧ 1 ≤ ENNReal.toReal p
Theorem: MeasureTheory.integral_fn_integral_add
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: refine' integral_congr_ae _
state_before: α : Type u_1
α' : Type ?u.2415704
β : Type u_2
β' : Type ?u.2415710
γ : Type ?u.2415713
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → E'
hf : Integrable f
hg : Integrable g
⊢ (∫ (x : α), F (∫ (y : β), f (x, y) + g (x, y) ∂ν) ∂μ) =
    ∫ (x : α), F ((∫ (y : β), f (x, y) ∂ν) + ∫ (y : β), g (x, y) ∂ν) ∂μ

tactic: filter_upwards [hf.prod_right_ae, hg.prod_right_ae] with _ h2f h2g
state_before: α : Type u_1
α' : Type ?u.2415704
β : Type u_2
β' : Type ?u.2415710
γ : Type ?u.2415713
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → E'
hf : Integrable f
hg : Integrable g
⊢ (fun x => F (∫ (y : β), f (x, y) + g (x, y) ∂ν)) =ᶠ[ae μ] fun x =>
    F ((∫ (y : β), f (x, y) ∂ν) + ∫ (y : β), g (x, y) ∂ν)

tactic: simp [integral_add h2f h2g]
state_before: case h
α : Type u_1
α' : Type ?u.2415704
β : Type u_2
β' : Type ?u.2415710
γ : Type ?u.2415713
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type u_4
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → E'
hf : Integrable f
hg : Integrable g
a✝ : α
h2f : Integrable fun y => f (a✝, y)
h2g : Integrable fun y => g (a✝, y)
⊢ F (∫ (y : β), f (a✝, y) + g (a✝, y) ∂ν) = F ((∫ (y : β), f (a✝, y) ∂ν) + ∫ (y : β), g (a✝, y) ∂ν)
Theorem: lowerSemicontinuousAt_ciSup
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp_rw [← lowerSemicontinuousWithinAt_univ_iff] at *
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type ?u.117874
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Sort u_3
δ : Type ?u.117903
δ' : Type u_2
inst✝¹ : CompleteLinearOrder δ
inst✝ : ConditionallyCompleteLinearOrder δ'
f : ι → α → δ'
bdd : ∀ᶠ (y : α) in 𝓝 x, BddAbove (range fun i => f i y)
h : ∀ (i : ι), LowerSemicontinuousAt (f i) x
⊢ LowerSemicontinuousAt (fun x' => ⨆ (i : ι), f i x') x

tactic: rw [← nhdsWithin_univ] at bdd
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type ?u.117874
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Sort u_3
δ : Type ?u.117903
δ' : Type u_2
inst✝¹ : CompleteLinearOrder δ
inst✝ : ConditionallyCompleteLinearOrder δ'
f : ι → α → δ'
bdd : ∀ᶠ (y : α) in 𝓝 x, BddAbove (range fun i => f i y)
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) univ x
⊢ LowerSemicontinuousWithinAt (fun x' => ⨆ (i : ι), f i x') univ x

tactic: exact lowerSemicontinuousWithinAt_ciSup bdd h
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type ?u.117874
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Sort u_3
δ : Type ?u.117903
δ' : Type u_2
inst✝¹ : CompleteLinearOrder δ
inst✝ : ConditionallyCompleteLinearOrder δ'
f : ι → α → δ'
bdd : ∀ᶠ (y : α) in 𝓝[univ] x, BddAbove (range fun i => f i y)
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) univ x
⊢ LowerSemicontinuousWithinAt (fun x' => ⨆ (i : ι), f i x') univ x
Theorem: MulAction.pow_smul_eq_iff_minimalPeriod_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← isPeriodicPt_iff_minimalPeriod_dvd, IsPeriodicPt, IsFixedPt, smul_iterate]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Group α
inst✝ : MulAction α β
a : α
b : β
n : ℕ
⊢ a ^ n • b = b ↔ minimalPeriod ((fun x x_1 => x • x_1) a) b ∣ n
Theorem: PadicSeq.lift_index_left_left
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: apply stationaryPoint_spec hf
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v2 v3 : ℕ
⊢ padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑f (max (stationaryPoint hf) (max v2 v3)))

tactic: apply le_max_left
state_before: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v2 v3 : ℕ
⊢ stationaryPoint hf ≤ max (stationaryPoint hf) (max v2 v3)

tactic: exact le_rfl
state_before: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v2 v3 : ℕ
⊢ stationaryPoint hf ≤ stationaryPoint hf
Theorem: MeasureTheory.measure_biUnion_finset₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← Finset.sum_attach, Finset.attach_eq_univ, ← tsum_fintype]
state_before: α : Type u_2
β : Type ?u.12040
γ : Type ?u.12043
δ : Type ?u.12046
ι : Type u_1
R : Type ?u.12052
R' : Type ?u.12055
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Finset ι
f : ι → Set α
hd : Set.Pairwise (↑s) (AEDisjoint μ on f)
hm : ∀ (b : ι), b ∈ s → NullMeasurableSet (f b)
⊢ ↑↑μ (⋃ (b : ι) (_ : b ∈ s), f b) = ∑ p in s, ↑↑μ (f p)

tactic: exact measure_biUnion₀ s.countable_toSet hd hm
state_before: α : Type u_2
β : Type ?u.12040
γ : Type ?u.12043
δ : Type ?u.12046
ι : Type u_1
R : Type ?u.12052
R' : Type ?u.12055
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Finset ι
f : ι → Set α
hd : Set.Pairwise (↑s) (AEDisjoint μ on f)
hm : ∀ (b : ι), b ∈ s → NullMeasurableSet (f b)
⊢ ↑↑μ (⋃ (b : ι) (_ : b ∈ s), f b) = ∑' (b : { x // x ∈ s }), ↑↑μ (f ↑b)
Theorem: Quiver.Path.toList_injective
File: Mathlib/Combinatorics/Quiver/Path.lean

tactic: cases h
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a c : V
p : Path a c
f : c ⟶ a
h : toList nil = toList (cons p f)
⊢ nil = cons p f

tactic: cases h
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a c : V
p : Path a c
f : c ⟶ a
h : toList (cons p f) = toList nil
⊢ cons p f = nil

tactic: simp only [toList, List.cons.injEq] at h
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
t : V
C : Path a t
D : t ⟶ x✝
h : toList (cons p f) = toList (cons C D)
⊢ cons p f = cons C D

tactic: obtain ⟨rfl, hAC⟩ := h
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
t : V
C : Path a t
D : t ⟶ x✝
h : c = t ∧ toList p = toList C
⊢ cons p f = cons C D

tactic: simp [toList_injective _ _ hAC]
state_before: case intro
V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
C : Path a c
D : c ⟶ x✝
hAC : toList p = toList C
⊢ cons p f = cons C D
Theorem: upperSemicontinuousOn_univ_iff
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp [UpperSemicontinuousOn, UpperSemicontinuous, upperSemicontinuousWithinAt_univ_iff]
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f g : α → β
x : α
s t : Set α
y z : β
⊢ UpperSemicontinuousOn f univ ↔ UpperSemicontinuous f
Theorem: Int.neg_lt_of_neg_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.neg_lt_neg h
state_before: a b : Int
h : -a < b
⊢ -b < a

tactic: rwa [Int.neg_neg] at h
state_before: a b : Int
h✝ : -a < b
h : -b < - -a
⊢ -b < a
Theorem: Cardinal.nfpBFamily_lt_ord_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [lift_id]
state_before: α : Type ?u.163687
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
ho : card o < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal) (hi : i < o) (b : Ordinal), b < ord c → f i hi b < ord c
a : Ordinal
⊢ lift (card o) < c
Theorem: Fin.tail_update_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
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
⊢ tail (update q 0 z) = tail q

tactic: simp [tail, Fin.succ_ne_zero]
state_before: case h
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
j : Fin n
⊢ tail (update q 0 z) j = tail q j
Theorem: Function.not_surjective_Type
File: Mathlib/Logic/Function/Basic.lean

tactic: intro hf
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
⊢ ¬Surjective f

tactic: let T : Type max u v := Sigma f
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
⊢ False

tactic: cases' hf (Set T) with U hU
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
⊢ False

tactic: let g : Set T → T := fun s ↦ ⟨U, cast hU.symm s⟩
state_before: case intro
α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
U : α
hU : f U = Set T
⊢ False

tactic: exact cantor_injective g hg
state_before: case intro
α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
U : α
hU : f U = Set T
g : Set T → T := fun s => { fst := U, snd := cast (_ : Set T = f U) s }
hg : Injective g
⊢ False

tactic: intro s t h
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
U : α
hU : f U = Set T
g : Set T → T := fun s => { fst := U, snd := cast (_ : Set T = f U) s }
⊢ Injective g

tactic: suffices cast hU (g s).2 = cast hU (g t).2 by
  simp only [cast_cast, cast_eq] at this
  assumption
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
U : α
hU : f U = Set T
g : Set T → T := fun s => { fst := U, snd := cast (_ : Set T = f U) s }
s t : Set T
h : g s = g t
⊢ s = t

tactic: simp only [cast_cast, cast_eq] at this
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
U : α
hU : f U = Set T
g : Set T → T := fun s => { fst := U, snd := cast (_ : Set T = f U) s }
s t : Set T
h : g s = g t
this : cast hU (g s).snd = cast hU (g t).snd
⊢ s = t

tactic: assumption
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
U : α
hU : f U = Set T
g : Set T → T := fun s => { fst := U, snd := cast (_ : Set T = f U) s }
s t : Set T
h : g s = g t
this : s = t
⊢ s = t

tactic: congr
state_before: α✝ : Sort ?u.9302
β : Sort ?u.9305
γ : Sort ?u.9308
f✝ : α✝ → β
α : Type u
f : α → Type (max u v)
hf : Surjective f
T : Type (max u v) := Sigma f
U : α
hU : f U = Set T
g : Set T → T := fun s => { fst := U, snd := cast (_ : Set T = f U) s }
s t : Set T
h : g s = g t
⊢ cast hU (g s).snd = cast hU (g t).snd
Theorem: IsUnit.eq_div_iff
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [div_eq_mul_inv, h.eq_mul_inv_iff_mul_eq]
state_before: F : Type ?u.57889
G : Type ?u.57892
α : Type u_1
M : Type ?u.57898
N : Type ?u.57901
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit c
⊢ a = b / c ↔ a * c = b
Theorem: MvPolynomial.coeff_eval_eq_eval_coeff
File: Mathlib/Data/MvPolynomial/Equiv.lean

tactic: simp only [Polynomial.coeff_map]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1195723
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
s' : Fin n → R
f : (MvPolynomial (Fin n) R)[X]
i : ℕ
⊢ Polynomial.coeff (Polynomial.map (eval s') f) i = ↑(eval s') (Polynomial.coeff f i)
Theorem: norm_zsmul
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [← norm_smul, ← Int.smul_one_eq_coe, smul_assoc, one_smul]
state_before: α✝ : Type ?u.4110
β : Type u_2
γ : Type ?u.4116
ι : Type ?u.4119
inst✝³ : NormedField α✝
inst✝² : SeminormedAddCommGroup β
α : Type u_1
inst✝¹ : NormedField α
inst✝ : NormedSpace α β
n : ℤ
x : β
⊢ ‖n • x‖ = ‖↑n‖ * ‖x‖
Theorem: FirstOrder.Language.Theory.IsComplete.realize_sentence_iff
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: cases' h.2 φ with hφ hφn
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
h : IsComplete T
φ : Sentence L
M : Type u_1
inst✝² : Structure L M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
⊢ M ⊨ φ ↔ T ⊨ᵇ φ

tactic: exact iff_of_true (hφ.realize_sentence M) hφ
state_before: case inl
L : Language
T : Theory L
α : Type w
n : ℕ
h : IsComplete T
φ : Sentence L
M : Type u_1
inst✝² : Structure L M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
hφ : T ⊨ᵇ φ
⊢ M ⊨ φ ↔ T ⊨ᵇ φ

tactic: exact
  iff_of_false ((Sentence.realize_not M).1 (hφn.realize_sentence M))
    ((h.models_not_iff φ).1 hφn)
state_before: case inr
L : Language
T : Theory L
α : Type w
n : ℕ
h : IsComplete T
φ : Sentence L
M : Type u_1
inst✝² : Structure L M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
hφn : T ⊨ᵇ Formula.not φ
⊢ M ⊨ φ ↔ T ⊨ᵇ φ
Theorem: TopHom.cancel_left
File: Mathlib/Order/Hom/Bounded.lean

tactic: rw [← TopHom.comp_apply, h, TopHom.comp_apply]
state_before: F : Type ?u.24533
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.24545
inst✝³ : Top α
inst✝² : Top β
inst✝¹ : Top γ
inst✝ : Top δ
g : TopHom β γ
f₁ f₂ : TopHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)