tasksource/leandojo huggingface dataset:
Theorem: Int.fract_neg_eq_zero
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp only [fract_eq_iff, le_refl, zero_lt_one, tsub_zero, true_and_iff]
state_before: F : Type ?u.172838
α : Type u_1
β : Type ?u.172844
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
⊢ fract (-x) = 0 ↔ fract x = 0

tactic: constructor <;> rintro ⟨z, hz⟩ <;> use -z <;> simp [← hz]
state_before: F : Type ?u.172838
α : Type u_1
β : Type ?u.172844
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
⊢ (∃ z, -x = ↑z) ↔ ∃ z, x = ↑z
Theorem: Equiv.Perm.support_swap
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: ext z
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : x ≠ y
⊢ support (swap x y) = {x, y}

tactic: by_cases hx : z = x
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : x ≠ y
z : α
⊢ z ∈ support (swap x y) ↔ z ∈ {x, y}

tactic: any_goals simpa [hx] using h.symm
state_before: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : x ≠ y
z : α
hx : z = x
⊢ z ∈ support (swap x y) ↔ z ∈ {x, y}

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : x ≠ y
z : α
hx : ¬z = x
⊢ z ∈ support (swap x y) ↔ z ∈ {x, y}

tactic: simpa [hx] using h.symm
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : x ≠ y
z : α
hx : ¬z = x
⊢ z ∈ support (swap x y) ↔ z ∈ {x, y}

tactic: simp [swap_apply_of_ne_of_ne, hx, hy] <;>
exact h
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : x ≠ y
z : α
hx : ¬z = x
hy : ¬z = y
⊢ z ∈ support (swap x y) ↔ z ∈ {x, y}
Theorem: Polynomial.eq_zero_of_degree_lt_of_eval_finset_eq_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [← mem_degreeLT] at degree_f_lt
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : degree f < ↑(Finset.card s)
eval_f : ∀ (x : R), x ∈ s → eval x f = 0
⊢ f = 0

tactic: simp_rw [eval_eq_sum_degreeLTEquiv degree_f_lt] at eval_f
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R (Finset.card s)
eval_f : ∀ (x : R), x ∈ s → eval x f = 0
⊢ f = 0

tactic: rw [← degreeLTEquiv_eq_zero_iff_eq_zero degree_f_lt]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R (Finset.card s)
eval_f :
  ∀ (x : R),
    x ∈ s →
      ∑ x_1 : Fin (Finset.card s),
          ↑(degreeLTEquiv R (Finset.card s)) { val := f, property := degree_f_lt } x_1 * x ^ ↑x_1 =
        0
⊢ f = 0

tactic: exact
  Matrix.eq_zero_of_forall_index_sum_mul_pow_eq_zero
    (Injective.comp (Embedding.subtype _).inj' (equivFinOfCardEq (card_coe _)).symm.injective)
    fun _ => eval_f _ (Finset.coe_mem _)
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R (Finset.card s)
eval_f :
  ∀ (x : R),
    x ∈ s →
      ∑ x_1 : Fin (Finset.card s),
          ↑(degreeLTEquiv R (Finset.card s)) { val := f, property := degree_f_lt } x_1 * x ^ ↑x_1 =
        0
⊢ ↑(degreeLTEquiv R (Finset.card s)) { val := f, property := degree_f_lt } = 0
Theorem: FirstOrder.Language.BoundedFormula.relabel_all
File: Mathlib/ModelTheory/Syntax.lean

tactic: rw [relabel, mapTermRel, relabel]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.96264
P : Type ?u.96267
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.96295
n : ℕ
g : α → β ⊕ Fin n
k : ℕ
φ : BoundedFormula L α (k + 1)
⊢ relabel g (all φ) = all (relabel g φ)

tactic: simp
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.96264
P : Type ?u.96267
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.96295
n : ℕ
g : α → β ⊕ Fin n
k : ℕ
φ : BoundedFormula L α (k + 1)
⊢ all
      (castLE (_ : n + k + 1 ≥ n + (k + 1))
        (mapTermRel (fun x t => Term.relabel (relabelAux g x) t) (fun x => id)
          (fun x => castLE (_ : n + x + 1 ≥ n + (x + 1))) φ)) =
    all
      (mapTermRel (fun x t => Term.relabel (relabelAux g x) t) (fun x => id)
        (fun x => castLE (_ : n + x + 1 ≥ n + (x + 1))) φ)
Theorem: map_congr
File: src/lean/Init/Control/Lawful.lean

tactic: simp [funext h]
state_before: m : Type u_1 → Type u_2
α β : Type u_1
inst✝ : Functor m
x : m α
f g : α → β
h : ∀ (a : α), f a = g a
⊢ f <$> x = g <$> x
Theorem: Finset.fold_min_le
File: Mathlib/Data/Finset/Fold.lean

tactic: show _ ≥ _ ↔ _
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.65002
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ fold min b f s ≤ c ↔ b ≤ c ∨ ∃ x, x ∈ s ∧ f x ≤ c

tactic: apply fold_op_rel_iff_or
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.65002
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ c ≥ fold min b f s ↔ b ≤ c ∨ ∃ x, x ∈ s ∧ f x ≤ c

tactic: intro x y z
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.65002
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ ∀ {x y z : β}, x ≥ min y z ↔ x ≥ y ∨ x ≥ z

tactic: show _ ≤ _ ↔ _
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.65002
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c x y z : β
⊢ x ≥ min y z ↔ x ≥ y ∨ x ≥ z

tactic: exact min_le_iff
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.65002
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c x y z : β
⊢ min y z ≤ x ↔ x ≥ y ∨ x ≥ z
Theorem: Sigma.ext
File: Mathlib/Data/Sigma/Basic.lean

tactic: cases x₀
state_before: α : Type u_1
α₁ : Type ?u.2624
α₂ : Type ?u.2627
β : α → Type u_2
β₁ : α₁ → Type ?u.2637
β₂ : α₂ → Type ?u.2642
x₀ x₁ : Sigma β
h₀ : x₀.fst = x₁.fst
h₁ : HEq x₀.snd x₁.snd
⊢ x₀ = x₁

tactic: cases x₁
state_before: case mk
α : Type u_1
α₁ : Type ?u.2624
α₂ : Type ?u.2627
β : α → Type u_2
β₁ : α₁ → Type ?u.2637
β₂ : α₂ → Type ?u.2642
x₁ : Sigma β
fst✝ : α
snd✝ : β fst✝
h₀ : { fst := fst✝, snd := snd✝ }.fst = x₁.fst
h₁ : HEq { fst := fst✝, snd := snd✝ }.snd x₁.snd
⊢ { fst := fst✝, snd := snd✝ } = x₁

tactic: cases h₀
state_before: case mk.mk
α : Type u_1
α₁ : Type ?u.2624
α₂ : Type ?u.2627
β : α → Type u_2
β₁ : α₁ → Type ?u.2637
β₂ : α₂ → Type ?u.2642
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
h₀ : { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst
h₁ : HEq { fst := fst✝¹, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
⊢ { fst := fst✝¹, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ }

tactic: cases h₁
state_before: case mk.mk.refl
α : Type u_1
α₁ : Type ?u.2624
α₂ : Type ?u.2627
β : α → Type u_2
β₁ : α₁ → Type ?u.2637
β₂ : α₂ → Type ?u.2642
fst✝ : α
snd✝¹ snd✝ : β fst✝
h₁ : HEq { fst := fst✝, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
⊢ { fst := fst✝, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ }

tactic: rfl
state_before: case mk.mk.refl.refl
α : Type u_1
α₁ : Type ?u.2624
α₂ : Type ?u.2627
β : α → Type u_2
β₁ : α₁ → Type ?u.2637
β₂ : α₂ → Type ?u.2642
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝, snd := snd✝ } = { fst := fst✝, snd := snd✝ }
Theorem: ContinuousLinearMap.nnnorm_def
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: ext
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.604089
E : Type u_3
Eₗ : Type ?u.604095
F : Type u_4
Fₗ : Type ?u.604101
G : Type ?u.604104
Gₗ : Type ?u.604107
𝓕 : Type ?u.604110
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 σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x : E
f : E →SL[σ₁₂] F
⊢ ‖f‖₊ = sInf {c | ∀ (x : E), ‖↑f x‖₊ ≤ c * ‖x‖₊}

tactic: rw [NNReal.coe_sInf, coe_nnnorm, norm_def, NNReal.coe_image]
state_before: case a
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.604089
E : Type u_3
Eₗ : Type ?u.604095
F : Type u_4
Fₗ : Type ?u.604101
G : Type ?u.604104
Gₗ : Type ?u.604107
𝓕 : Type ?u.604110
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 σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x : E
f : E →SL[σ₁₂] F
⊢ ↑‖f‖₊ = ↑(sInf {c | ∀ (x : E), ‖↑f x‖₊ ≤ c * ‖x‖₊})

tactic: simp_rw [← NNReal.coe_le_coe, NNReal.coe_mul, coe_nnnorm, mem_setOf_eq, Subtype.coe_mk,
  exists_prop, NNReal.coe_mk, exists_prop]
state_before: case a
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.604089
E : Type u_3
Eₗ : Type ?u.604095
F : Type u_4
Fₗ : Type ?u.604101
G : Type ?u.604104
Gₗ : Type ?u.604107
𝓕 : Type ?u.604110
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 σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x : E
f : E →SL[σ₁₂] F
⊢ sInf {c | 0 ≤ c ∧ ∀ (x : E), ‖↑f x‖ ≤ c * ‖x‖} =
    sInf {x | ∃ h, { val := x, property := h } ∈ {c | ∀ (x : E), ‖↑f x‖₊ ≤ c * ‖x‖₊}}
Theorem: isOpen_setOf_disjoint_nhds_nhds
File: Mathlib/Topology/Separation.lean

tactic: simp only [isOpen_iff_mem_nhds, Prod.forall, mem_setOf_eq]
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
⊢ IsOpen {p | Disjoint (𝓝 p.fst) (𝓝 p.snd)}

tactic: intro x y h
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
⊢ ∀ (a b : α), Disjoint (𝓝 a) (𝓝 b) → {p | Disjoint (𝓝 p.fst) (𝓝 p.snd)} ∈ 𝓝 (a, b)

tactic: obtain ⟨U, hU, V, hV, hd⟩ := ((nhds_basis_opens x).disjoint_iff (nhds_basis_opens y)).mp h
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
x y : α
h : Disjoint (𝓝 x) (𝓝 y)
⊢ {p | Disjoint (𝓝 p.fst) (𝓝 p.snd)} ∈ 𝓝 (x, y)

tactic: exact
  mem_nhds_prod_iff.mpr
    ⟨U, hU.2.mem_nhds hU.1, V, hV.2.mem_nhds hV.1, fun ⟨x', y'⟩ ⟨hx', hy'⟩ =>
      disjoint_of_disjoint_of_mem hd (hU.2.mem_nhds hx') (hV.2.mem_nhds hy')⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
inst✝ : TopologicalSpace α
x y : α
h : Disjoint (𝓝 x) (𝓝 y)
U : Set α
hU : x ∈ U ∧ IsOpen U
V : Set α
hV : y ∈ V ∧ IsOpen V
hd : Disjoint U V
⊢ {p | Disjoint (𝓝 p.fst) (𝓝 p.snd)} ∈ 𝓝 (x, y)
Theorem: SimpleGraph.Subgraph.edgeSet_bot
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp
state_before: ι : Sort ?u.102767
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
⊢ ∀ (x y : V), Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet ⊥ ↔ Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ ∅
Theorem: AntilipschitzWith.bounded_preimage
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: gcongr
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.15366
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
s : Set β
hs : Metric.Bounded s
x : α
hx : x ∈ f ⁻¹' s
y : α
hy : y ∈ f ⁻¹' s
⊢ ↑K * dist (f x) (f y) ≤ ↑K * diam s

tactic: exact dist_le_diam_of_mem hs hx hy
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.15366
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
s : Set β
hs : Metric.Bounded s
x : α
hx : x ∈ f ⁻¹' s
y : α
hy : y ∈ f ⁻¹' s
⊢ dist (f x) (f y) ≤ diam s
Theorem: Hyperreal.infiniteNeg_mul_of_infiniteNeg_not_infinitesimal_pos
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [← infinitePos_neg, ← infinitePos_neg, neg_mul_eq_neg_mul]
state_before: x y : ℝ*
⊢ InfiniteNeg x → ¬Infinitesimal y → 0 < y → InfiniteNeg (x * y)

tactic: exact infinitePos_mul_of_infinitePos_not_infinitesimal_pos
state_before: x y : ℝ*
⊢ InfinitePos (-x) → ¬Infinitesimal y → 0 < y → InfinitePos (-x * y)
Theorem: BilinForm.isSkewAdjoint_iff_neg_self_adjoint
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: simp only [LinearMap.neg_apply, BilinForm.neg_apply, BilinForm.neg_right]
state_before: R : Type ?u.1220676
M : Type ?u.1220679
inst✝²⁴ : Semiring R
inst✝²³ : AddCommMonoid M
inst✝²² : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝²¹ : Ring R₁
inst✝²⁰ : AddCommGroup M₁
inst✝¹⁹ : Module R₁ M₁
R₂ : Type ?u.1221327
M₂ : Type ?u.1221330
inst✝¹⁸ : CommSemiring R₂
inst✝¹⁷ : AddCommMonoid M₂
inst✝¹⁶ : Module R₂ M₂
R₃ : Type ?u.1221517
M₃ : Type ?u.1221520
inst✝¹⁵ : CommRing R₃
inst✝¹⁴ : AddCommGroup M₃
inst✝¹³ : Module R₃ M₃
V : Type ?u.1222108
K : Type ?u.1222111
inst✝¹² : Field K
inst✝¹¹ : AddCommGroup V
inst✝¹⁰ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1223325
M₂'' : Type ?u.1223328
inst✝⁹ : AddCommMonoid M₂'
inst✝⁸ : AddCommMonoid M₂''
inst✝⁷ : Module R₂ M₂'
inst✝⁶ : Module R₂ M₂''
F : BilinForm R M
M' : Type ?u.1223639
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
B' : BilinForm R M'
f✝ f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
M₁' : Type ?u.1224076
inst✝³ : AddCommGroup M₁'
inst✝² : Module R₁ M₁'
B₁' : BilinForm R₁ M₁'
f₁ f₁' : M₁ →ₗ[R₁] M₁'
g₁ g₁' : M₁' →ₗ[R₁] M₁
B₂' : BilinForm R₂ M₂'
f₂ f₂' : M₂ →ₗ[R₂] M₂'
g₂ g₂' : M₂' →ₗ[R₂] M₂
M'' : Type ?u.1226555
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
B'' : BilinForm R M''
F₂ : BilinForm R₂ M₂
f : Module.End R₁ M₁
⊢ (∀ (x y : M₁), bilin B₁ (↑f x) y = bilin B₁ x (↑(-f) y)) ↔ ∀ (x y : M₁), bilin B₁ (↑f x) y = bilin (-B₁) x (↑f y)
Theorem: IsBezout.iff_span_pair_isPrincipal
File: Mathlib/RingTheory/Bezout.lean

tactic: constructor
state_before: R : Type u
inst✝ : CommRing R
⊢ IsBezout R ↔ ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})

tactic: intro H x y
state_before: case mp
R : Type u
inst✝ : CommRing R
⊢ IsBezout R → ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})

tactic: infer_instance
state_before: case mp
R : Type u
inst✝ : CommRing R
H : IsBezout R
x y : R
⊢ Submodule.IsPrincipal (Ideal.span {x, y})

tactic: intro H
state_before: case mpr
R : Type u
inst✝ : CommRing R
⊢ (∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})) → IsBezout R

tactic: constructor
state_before: case mpr
R : Type u
inst✝ : CommRing R
H : ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})
⊢ IsBezout R

tactic: apply Submodule.fg_induction
state_before: case mpr.isPrincipal_of_FG
R : Type u
inst✝ : CommRing R
H : ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})
⊢ ∀ (I : Ideal R), Ideal.FG I → Submodule.IsPrincipal I

tactic: exact fun _ => ⟨⟨_, rfl⟩⟩
state_before: case mpr.isPrincipal_of_FG.h₁
R : Type u
inst✝ : CommRing R
H : ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})
⊢ ∀ (x : R), Submodule.IsPrincipal (Submodule.span R {x})

tactic: rintro _ _ ⟨⟨x, rfl⟩⟩ ⟨⟨y, rfl⟩⟩
state_before: case mpr.isPrincipal_of_FG.h₂
R : Type u
inst✝ : CommRing R
H : ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})
⊢ ∀ (M₁ M₂ : Submodule R R), Submodule.IsPrincipal M₁ → Submodule.IsPrincipal M₂ → Submodule.IsPrincipal (M₁ ⊔ M₂)

tactic: rw [← Submodule.span_insert]
state_before: case mpr.isPrincipal_of_FG.h₂.mk.intro.mk.intro
R : Type u
inst✝ : CommRing R
H : ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})
x y : R
⊢ Submodule.IsPrincipal (Submodule.span R {x} ⊔ Submodule.span R {y})

tactic: exact H _ _
state_before: case mpr.isPrincipal_of_FG.h₂.mk.intro.mk.intro
R : Type u
inst✝ : CommRing R
H : ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})
x y : R
⊢ Submodule.IsPrincipal (Submodule.span R {x, y})
Theorem: Nat.factorization_eq_zero_of_remainder
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: apply factorization_eq_zero_of_not_dvd
state_before: p r i : ℕ
hr : ¬p ∣ r
⊢ ↑(factorization (p * i + r)) p = 0

tactic: rwa [← Nat.dvd_add_iff_right (Dvd.intro i rfl)]
state_before: case h
p r i : ℕ
hr : ¬p ∣ r
⊢ ¬p ∣ p * i + r
Theorem: Tropical.add_eq_iff
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: rw [trop_add_def, trop_eq_iff_eq_untrop]
state_before: R : Type u
inst✝ : LinearOrder R
x y z : Tropical R
⊢ x + y = z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x

tactic: simp [min_eq_iff]
state_before: R : Type u
inst✝ : LinearOrder R
x y z : Tropical R
⊢ min (untrop x) (untrop y) = untrop z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x
Theorem: List.foldr_max_of_ne_nil
File: Mathlib/Data/List/MinMax.lean

tactic: induction' l with hd tl IH
state_before: α : Type u_1
β : Type ?u.107747
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
h : l ≠ []
⊢ ↑(foldr max ⊥ l) = maximum l

tactic: contradiction
state_before: case nil
α : Type u_1
β : Type ?u.107747
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
h✝ : l ≠ []
h : [] ≠ []
⊢ ↑(foldr max ⊥ []) = maximum []

tactic: rw [maximum_cons, foldr, WithBot.coe_max]
state_before: case cons
α : Type u_1
β : Type ?u.107747
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
h✝ : l ≠ []
hd : α
tl : List α
IH : tl ≠ [] → ↑(foldr max ⊥ tl) = maximum tl
h : hd :: tl ≠ []
⊢ ↑(foldr max ⊥ (hd :: tl)) = maximum (hd :: tl)

tactic: by_cases h : tl = []
state_before: case cons
α : Type u_1
β : Type ?u.107747
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
h✝ : l ≠ []
hd : α
tl : List α
IH : tl ≠ [] → ↑(foldr max ⊥ tl) = maximum tl
h : hd :: tl ≠ []
⊢ max ↑hd ↑(foldr max ⊥ tl) = max (↑hd) (maximum tl)

tactic: simp [h]
state_before: case pos
α : Type u_1
β : Type ?u.107747
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
h✝¹ : l ≠ []
hd : α
tl : List α
IH : tl ≠ [] → ↑(foldr max ⊥ tl) = maximum tl
h✝ : hd :: tl ≠ []
h : tl = []
⊢ max ↑hd ↑(foldr max ⊥ tl) = max (↑hd) (maximum tl)

tactic: simp [IH h]
state_before: case neg
α : Type u_1
β : Type ?u.107747
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
h✝¹ : l ≠ []
hd : α
tl : List α
IH : tl ≠ [] → ↑(foldr max ⊥ tl) = maximum tl
h✝ : hd :: tl ≠ []
h : ¬tl = []
⊢ max ↑hd ↑(foldr max ⊥ tl) = max (↑hd) (maximum tl)
Theorem: norm_lt_of_mem_ball'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rwa [← dist_eq_norm_div]
state_before: 𝓕 : Type ?u.97056
𝕜 : Type ?u.97059
α : Type ?u.97062
ι : Type ?u.97065
κ : Type ?u.97068
E : Type u_1
F : Type ?u.97074
G : Type ?u.97077
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
h : b ∈ ball a r
⊢ ‖b / a‖ < r
Theorem: Filter.frequently_iff_forall_eventually_exists_and
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa only [and_not_self_iff, exists_false] using H hp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.160738
ι : Sort x
p : α → Prop
f : Filter α
H : ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x
hp : ∀ᶠ (x : α) in f, ¬(fun x => p x) x
⊢ False
Theorem: Projectivization.independent_iff
File: Mathlib/LinearAlgebra/ProjectiveSpace/Independence.lean

tactic: refine' ⟨_, fun h => _⟩
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Independent f ↔ LinearIndependent K (Projectivization.rep ∘ f)

tactic: rintro ⟨ff, hff, hh⟩
state_before: case refine'_1
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Independent f → LinearIndependent K (Projectivization.rep ∘ f)

tactic: choose a ha using fun i : ι => exists_smul_eq_mk_rep K (ff i) (hff i)
state_before: case refine'_1.mk
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
ff : ι → V
hff : ∀ (i : ι), ff i ≠ 0
hh : LinearIndependent K ff
⊢ LinearIndependent K (Projectivization.rep ∘ fun i => mk K (ff i) (_ : ff i ≠ 0))

tactic: convert hh.units_smul a
state_before: case refine'_1.mk
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
ff : ι → V
hff : ∀ (i : ι), ff i ≠ 0
hh : LinearIndependent K ff
a : ι → Kˣ
ha : ∀ (i : ι), a i • ff i = Projectivization.rep (mk K (ff i) (_ : ff i ≠ 0))
⊢ LinearIndependent K (Projectivization.rep ∘ fun i => mk K (ff i) (_ : ff i ≠ 0))

tactic: ext i
state_before: case h.e'_4
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
ff : ι → V
hff : ∀ (i : ι), ff i ≠ 0
hh : LinearIndependent K ff
a : ι → Kˣ
ha : ∀ (i : ι), a i • ff i = Projectivization.rep (mk K (ff i) (_ : ff i ≠ 0))
⊢ (Projectivization.rep ∘ fun i => mk K (ff i) (_ : ff i ≠ 0)) = a • ff

tactic: exact (ha i).symm
state_before: case h.e'_4.h
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
ff : ι → V
hff : ∀ (i : ι), ff i ≠ 0
hh : LinearIndependent K ff
a : ι → Kˣ
ha : ∀ (i : ι), a i • ff i = Projectivization.rep (mk K (ff i) (_ : ff i ≠ 0))
i : ι
⊢ (Projectivization.rep ∘ fun i => mk K (ff i) (_ : ff i ≠ 0)) i = (a • ff) i

tactic: convert Independent.mk _ _ h
state_before: case refine'_2
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : LinearIndependent K (Projectivization.rep ∘ f)
⊢ Independent f

tactic: simp only [mk_rep, Function.comp_apply]
state_before: case h.e'_7.h
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : LinearIndependent K (Projectivization.rep ∘ f)
x✝ : ι
⊢ f x✝ = mk K ((Projectivization.rep ∘ f) x✝) (_ : ?m.12213 x✝ ≠ 0)

tactic: intro i
state_before: case refine'_2
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : LinearIndependent K (Projectivization.rep ∘ f)
⊢ ∀ (i : ι), (Projectivization.rep ∘ f) i ≠ 0

tactic: apply rep_nonzero
state_before: case refine'_2
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : LinearIndependent K (Projectivization.rep ∘ f)
i : ι
⊢ (Projectivization.rep ∘ f) i ≠ 0
Theorem: IsCompact.elim_finite_subfamily_closed
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa only [subset_def, not_forall, eq_empty_iff_forall_not_mem, mem_iUnion, exists_prop,
  mem_inter_iff, not_and, iff_self_iff, mem_iInter, mem_compl_iff] using hsZ
state_before: α : Type u
β : Type v
ι✝ : Type ?u.18164
π : ι✝ → Type ?u.18169
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
ι : Type v
hs : IsCompact s
Z : ι → Set α
hZc : ∀ (i : ι), IsClosed (Z i)
hsZ : (s ∩ ⋂ (i : ι), Z i) = ∅
⊢ s ⊆ ⋃ (i : ι), (fun i => Z iᶜ) i

tactic: simpa only [subset_def, not_forall, eq_empty_iff_forall_not_mem, mem_iUnion, exists_prop,
mem_inter_iff, not_and, iff_self_iff, mem_iInter, mem_compl_iff] using ht
state_before: α : Type u
β : Type v
ι✝ : Type ?u.18164
π : ι✝ → Type ?u.18169
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t✝ s : Set α
ι : Type v
hs : IsCompact s
Z : ι → Set α
hZc : ∀ (i : ι), IsClosed (Z i)
hsZ : (s ∩ ⋂ (i : ι), Z i) = ∅
t : Finset ι
ht : s ⊆ ⋃ (i : ι) (_ : i ∈ t), Z iᶜ
⊢ (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) = ∅