1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: EMetric.hausdorffEdist_empty
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rcases ne with ⟨x, xs⟩
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
ne : s.Nonempty
⊢ hausdorffEdist s ∅ = ⊤
state_after: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t u : Set α
Φ : α → β
x : α
xs : x ∈ s
⊢ hausdorffEdist s ∅ = ⊤

tactic: have : infEdist x ∅ ≤ hausdorffEdist s ∅ := infEdist_le_hausdorffEdist_of_mem xs
state_before: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t u : Set α
Φ : α → β
x : α
xs : x ∈ s
⊢ hausdorffEdist s ∅ = ⊤
state_after: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t u : Set α
Φ : α → β
x : α
xs : x ∈ s
this : infEdist x ∅ ≤ hausdorffEdist s ∅
⊢ hausdorffEdist s ∅ = ⊤

tactic: simpa using this
state_before: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t u : Set α
Φ : α → β
x : α
xs : x ∈ s
this : infEdist x ∅ ≤ hausdorffEdist s ∅
⊢ hausdorffEdist s ∅ = ⊤
state_after: no goals
Theorem: IsLeftRegular.pow
File: Mathlib/Algebra/Regular/Pow.lean

tactic: simp only [IsLeftRegular, ← mul_left_iterate, rla.iterate n]
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
rla : IsLeftRegular a
⊢ IsLeftRegular (a ^ n)
state_after: no goals
Theorem: Finset.min_of_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: obtain ⟨b, h, _⟩ := inf_le (α := WithTop α) h _ rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h : a ∈ s
⊢ ∃ b, s.min = ↑b
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : s.inf WithTop.some = ↑b
right✝ : b ≤ a
⊢ ∃ b, s.min = ↑b

tactic: exact ⟨b, h⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : s.inf WithTop.some = ↑b
right✝ : b ≤ a
⊢ ∃ b, s.min = ↑b
state_after: no goals
Theorem: DoubleCentralizer.range_toProd
File: Mathlib/Analysis/NormedSpace/Star/Multiplier.lean

tactic: rintro ⟨a, rfl⟩
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
x : (A →L[𝕜] A) × (A →L[𝕜] A)
⊢ x ∈ Set.range toProd → x ∈ {lr | ∀ (x y : A), lr.2 x * y = x * lr.1 y}
state_after: case intro
𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
a : 𝓜(𝕜, A)
⊢ a.toProd ∈ {lr | ∀ (x y : A), lr.2 x * y = x * lr.1 y}

tactic: exact a.central
state_before: case intro
𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
a : 𝓜(𝕜, A)
⊢ a.toProd ∈ {lr | ∀ (x y : A), lr.2 x * y = x * lr.1 y}
state_after: no goals
Theorem: PrimeSpectrum.gc_set
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: have ideal_gc : GaloisConnection Ideal.span _ := (Submodule.gi R R).gc
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
⊢ GaloisConnection (fun s => zeroLocus s) fun t => ↑(vanishingIdeal t)
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ideal_gc : GaloisConnection Ideal.span SetLike.coe
⊢ GaloisConnection (fun s => zeroLocus s) fun t => ↑(vanishingIdeal t)

tactic: simpa [zeroLocus_span, Function.comp] using ideal_gc.compose (gc R)
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ideal_gc : GaloisConnection Ideal.span SetLike.coe
⊢ GaloisConnection (fun s => zeroLocus s) fun t => ↑(vanishingIdeal t)
state_after: no goals
Theorem: le_egauge_ball_one
File: Mathlib/Analysis/Convex/EGauge.lean

tactic: simpa using div_le_egauge_ball 𝕜 1 x
state_before: 𝕜 : Type u_1
inst✝² : NormedField 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
s t : Set E
x✝ y x : E
⊢ ↑‖x‖₊ ≤ egauge 𝕜 (ball 0 1) x
state_after: no goals
Theorem: Finset.sup_induction
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction s using Finset.cons_induction with
| empty => exact hb
| cons _ _ _ ih =>
  simp only [sup_cons, forall_mem_cons] at hs ⊢
  exact hp _ hs.1 _ (ih hs.2)
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
⊢ p (s.sup f)
state_after: no goals

tactic: exact hb
state_before: case empty
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ ∅, p (f b)
⊢ p (∅.sup f)
state_after: no goals

tactic: simp only [sup_cons, forall_mem_cons] at hs ⊢
state_before: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
a✝ : β
s✝ : Finset β
h✝ : a✝ ∉ s✝
ih : (∀ b ∈ s✝, p (f b)) → p (s✝.sup f)
hs : ∀ b ∈ cons a✝ s✝ h✝, p (f b)
⊢ p ((cons a✝ s✝ h✝).sup f)
state_after: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
a✝ : β
s✝ : Finset β
h✝ : a✝ ∉ s✝
ih : (∀ b ∈ s✝, p (f b)) → p (s✝.sup f)
hs : p (f a✝) ∧ ∀ x ∈ s✝, p (f x)
⊢ p (f a✝ ⊔ s✝.sup f)

tactic: exact hp _ hs.1 _ (ih hs.2)
state_before: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
a✝ : β
s✝ : Finset β
h✝ : a✝ ∉ s✝
ih : (∀ b ∈ s✝, p (f b)) → p (s✝.sup f)
hs : p (f a✝) ∧ ∀ x ∈ s✝, p (f x)
⊢ p (f a✝ ⊔ s✝.sup f)
state_after: no goals
Theorem: Submodule.IsPrincipal.eq_bot_iff_generator_eq_zero
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [← @span_singleton_eq_bot R M, span_singleton_generator]
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Ring R
inst✝¹ : Module R M
S : Submodule R M
inst✝ : S.IsPrincipal
⊢ S = ⊥ ↔ generator S = 0
state_after: no goals
Theorem: CanonicallyOrderedCommSemiring.multiset_prod_pos
File: Mathlib/Algebra/Order/BigOperators/Ring/Multiset.lean

tactic: rcases m with ⟨l⟩
state_before: R : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring R
inst✝ : Nontrivial R
m : Multiset R
⊢ 0 < m.prod ↔ ∀ x ∈ m, 0 < x
state_after: case mk
R : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring R
inst✝ : Nontrivial R
m : Multiset R
l : List R
⊢ 0 < prod (Quot.mk Setoid.r l) ↔ ∀ x ∈ Quot.mk Setoid.r l, 0 < x

tactic: rw [Multiset.quot_mk_to_coe'', Multiset.prod_coe]
state_before: case mk
R : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring R
inst✝ : Nontrivial R
m : Multiset R
l : List R
⊢ 0 < prod (Quot.mk Setoid.r l) ↔ ∀ x ∈ Quot.mk Setoid.r l, 0 < x
state_after: case mk
R : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring R
inst✝ : Nontrivial R
m : Multiset R
l : List R
⊢ 0 < l.prod ↔ ∀ x ∈ ↑l, 0 < x

tactic: exact CanonicallyOrderedCommSemiring.list_prod_pos
state_before: case mk
R : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring R
inst✝ : Nontrivial R
m : Multiset R
l : List R
⊢ 0 < l.prod ↔ ∀ x ∈ ↑l, 0 < x
state_after: no goals
Theorem: MeasureTheory.Measure.exists_isOpen_measure_lt_top
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: simpa only [and_assoc] using (μ.finiteAt_nhds x).exists_mem_basis (nhds_basis_opens x)
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : IsLocallyFiniteMeasure μ
x : α
⊢ ∃ s, x ∈ s ∧ IsOpen s ∧ μ s < ⊤
state_after: no goals
Theorem: MonoidHom.mrangeRestrict_mker
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

tactic: ext x
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
inst✝ : FunLike F M N
mc : MonoidHomClass F M N
f : M →* N
⊢ mker f.mrangeRestrict = mker f
state_after: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
inst✝ : FunLike F M N
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ x ∈ mker f.mrangeRestrict ↔ x ∈ mker f

tactic: change (⟨f x, _⟩ : mrange f) = ⟨1, _⟩ ↔ f x = 1
state_before: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
inst✝ : FunLike F M N
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ x ∈ mker f.mrangeRestrict ↔ x ∈ mker f
state_after: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
inst✝ : FunLike F M N
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ ⟨f x, ⋯⟩ = ⟨1, ⋯⟩ ↔ f x = 1

tactic: simp
state_before: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
inst✝ : FunLike F M N
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ ⟨f x, ⋯⟩ = ⟨1, ⋯⟩ ↔ f x = 1
state_after: no goals
Theorem: CategoryTheory.Arrow.inv_left
File: Mathlib/CategoryTheory/Comma/Arrow.lean

tactic: rw [← Comma.comp_left, IsIso.hom_inv_id, id_left]
state_before: T : Type u
inst✝¹ : Category.{v, u} T
f g : Arrow T
sq : f ⟶ g
inst✝ : IsIso sq
⊢ sq.left ≫ (inv sq).left = 𝟙 f.left
state_after: no goals
Theorem: LaurentPolynomial.T_sub
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: rw [← T_add, sub_eq_add_neg]
state_before: R : Type u_1
inst✝ : Semiring R
m n : ℤ
⊢ T (m - n) = T m * T (-n)
state_after: no goals
Theorem: Nat.shiftLeft'_false
File: Mathlib/Data/Nat/Bits.lean

tactic: have : 2 * (m * 2^n) = 2^(n+1)*m := by
  rw [Nat.mul_comm, Nat.mul_assoc, ← Nat.pow_succ]; simp
state_before: m n✝ n : ℕ
⊢ shiftLeft' false m (n + 1) = m <<< (n + 1)
state_after: m n✝ n : ℕ
this : 2 * (m * 2 ^ n) = 2 ^ (n + 1) * m
⊢ shiftLeft' false m (n + 1) = m <<< (n + 1)

tactic: simp [shiftLeft_eq, shiftLeft', bit_val, shiftLeft'_false, this]
state_before: m n✝ n : ℕ
this : 2 * (m * 2 ^ n) = 2 ^ (n + 1) * m
⊢ shiftLeft' false m (n + 1) = m <<< (n + 1)
state_after: no goals

tactic: rw [Nat.mul_comm, Nat.mul_assoc, ← Nat.pow_succ]
state_before: m n✝ n : ℕ
⊢ 2 * (m * 2 ^ n) = 2 ^ (n + 1) * m
state_after: m n✝ n : ℕ
⊢ m * 2 ^ n.succ = 2 ^ (n + 1) * m

tactic: simp
state_before: m n✝ n : ℕ
⊢ m * 2 ^ n.succ = 2 ^ (n + 1) * m
state_after: no goals
Theorem: PMF.toOuterMeasure_ofMultiset_apply
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: simp_rw [div_eq_mul_inv, ← ENNReal.tsum_mul_right, toOuterMeasure_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ (ofMultiset s hs).toOuterMeasure t =
    (∑' (x : α), ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s))) / ↑(Multiset.card s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ ∑' (x : α), t.indicator (⇑(ofMultiset s hs)) x =
    ∑' (i : α), ↑(Multiset.count i (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹

tactic: refine tsum_congr fun x => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ ∑' (x : α), t.indicator (⇑(ofMultiset s hs)) x =
    ∑' (i : α), ↑(Multiset.count i (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
x : α
⊢ t.indicator (⇑(ofMultiset s hs)) x = ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹

tactic: by_cases hx : x ∈ t <;> simp [Set.indicator, hx, div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
x : α
⊢ t.indicator (⇑(ofMultiset s hs)) x = ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹
state_after: no goals
Theorem: Nat.mul_dvd_mul_iff_right
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Nat.mul_right_comm, Nat.mul_left_inj $ ne_of_gt hc]
state_before: a b c d✝ m n k : ℕ
p q : ℕ → Prop
hc : 0 < c
d : ℕ
⊢ b * c = a * c * d ↔ b = a * d
state_after: no goals
Theorem: QuadraticForm.not_anisotropic_iff_exists
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [Anisotropic, not_forall, exists_prop, and_comm]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
⊢ ¬Q.Anisotropic ↔ ∃ x, x ≠ 0 ∧ Q x = 0
state_after: no goals
Theorem: mem_closure_iff_frequently
File: Mathlib/Topology/Basic.lean

tactic: rw [Filter.Frequently, Filter.Eventually, ← mem_interior_iff_mem_nhds,
  closure_eq_compl_interior_compl, mem_compl_iff, compl_def]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ x ∈ closure s ↔ ∃ᶠ (x : X) in 𝓝 x, x ∈ s
state_after: no goals
Theorem: quadraticChar_isQuadratic
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

tactic: intro a
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
⊢ (quadraticChar F).IsQuadratic
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1

tactic: by_cases ha : a = 0
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
state_after: case pos
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a = 0
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1

case neg
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : ¬a = 0
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1

tactic: left
state_before: case pos
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a = 0
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
state_after: case pos.h
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a = 0
⊢ (quadraticChar F) a = 0

tactic: rw [ha]
state_before: case pos.h
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a = 0
⊢ (quadraticChar F) a = 0
state_after: case pos.h
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a = 0
⊢ (quadraticChar F) 0 = 0

tactic: exact quadraticChar_zero
state_before: case pos.h
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a = 0
⊢ (quadraticChar F) 0 = 0
state_after: no goals

tactic: right
state_before: case neg
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : ¬a = 0
⊢ (quadraticChar F) a = 0 ∨ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
state_after: case neg.h
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : ¬a = 0
⊢ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1

tactic: exact quadraticChar_dichotomy ha
state_before: case neg.h
F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : ¬a = 0
⊢ (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
state_after: no goals
Theorem: Matrix.adjugate_fin_two
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: ext i j
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix (Fin 2) (Fin 2) α
⊢ A.adjugate = of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]]
state_after: case a
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ A.adjugate i j = of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]] i j

tactic: rw [adjugate_fin_succ_eq_det_submatrix]
state_before: case a
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ A.adjugate i j = of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]] i j
state_after: case a
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ (-1) ^ (↑j + ↑i) * (A.submatrix j.succAbove i.succAbove).det = of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]] i j

tactic: fin_cases i <;> fin_cases j <;> simp
state_before: case a
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ (-1) ^ (↑j + ↑i) * (A.submatrix j.succAbove i.succAbove).det = of ![![A 1 1, -A 0 1], ![-A 1 0, A 0 0]] i j
state_after: no goals
Theorem: Batteries.UnionFind.rank_push
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [rank]
state_before: a : Nat
m : UnionFind
⊢ m.push.rank a = m.rank a
state_after: no goals
Theorem: Multiset.prod_erase
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

tactic: rw [← s.coe_toList, coe_erase, prod_coe, prod_coe, List.prod_erase (mem_toList.2 h)]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq α
h : a ∈ s
⊢ a * (s.erase a).prod = s.prod
state_after: no goals
Theorem: himp_inf_himp_inf_le
File: Mathlib/Order/Heyting/Basic.lean

tactic: simpa using @himp_le_himp_himp_himp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ (b ⇨ c) ⊓ (a ⇨ b) ⊓ a ≤ c
state_after: no goals
Theorem: AddCommGroup.modEq_sub_iff_add_modEq
File: Mathlib/Algebra/ModEq.lean

tactic: rw [add_comm]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ c + a ≡ b [PMOD p] ↔ a + c ≡ b [PMOD p]
state_after: no goals
Theorem: Polynomial.opRingEquiv_op_C_mul_X_pow
File: Mathlib/RingTheory/Polynomial/Opposites.lean

tactic: simp only [X_pow_mul, op_mul, op_pow, map_mul, map_pow, opRingEquiv_op_X, opRingEquiv_op_C]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
n : ℕ
⊢ (opRingEquiv R) (op (C r * X ^ n)) = C (op r) * X ^ n
state_after: no goals
Theorem: Finsupp.prod_ite_eq
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: dsimp [Finsupp.prod]
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁶ : AddCommMonoid A
inst✝⁵ : AddCommMonoid B
inst✝⁴ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝³ : Zero M
inst✝² : Zero M'
inst✝¹ : CommMonoid N
inst✝ : DecidableEq α
f : α →₀ M
a : α
b : α → M → N
⊢ (f.prod fun x v => if a = x then b x v else 1) = if a ∈ f.support then b a (f a) else 1
state_after: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁶ : AddCommMonoid A
inst✝⁵ : AddCommMonoid B
inst✝⁴ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝³ : Zero M
inst✝² : Zero M'
inst✝¹ : CommMonoid N
inst✝ : DecidableEq α
f : α →₀ M
a : α
b : α → M → N
⊢ (∏ a_1 ∈ f.support, if a = a_1 then b a_1 (f a_1) else 1) = if a ∈ f.support then b a (f a) else 1

tactic: rw [f.support.prod_ite_eq]
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁶ : AddCommMonoid A
inst✝⁵ : AddCommMonoid B
inst✝⁴ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝³ : Zero M
inst✝² : Zero M'
inst✝¹ : CommMonoid N
inst✝ : DecidableEq α
f : α →₀ M
a : α
b : α → M → N
⊢ (∏ a_1 ∈ f.support, if a = a_1 then b a_1 (f a_1) else 1) = if a ∈ f.support then b a (f a) else 1
state_after: no goals
Theorem: List.count_cons_self
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: simp [count_cons]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
⊢ count a (a :: l) = count a l + 1
state_after: no goals
Theorem: Commute.inv
File: Mathlib/Algebra/Group/Commute/Defs.lean

tactic: rw [hab.eq, mul_inv_rev]
state_before: G : Type u_1
M : Type u_2
S : Type u_3
inst✝ : DivisionMonoid G
a b c d : G
hab : Commute a b
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
state_after: no goals
Theorem: ContinuousLinearMap.map_sub
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: exact map_sub f x y
state_before: R : Type u_1
inst✝¹³ : Ring R
R₂ : Type u_2
inst✝¹² : Ring R₂
R₃ : Type u_3
inst✝¹¹ : Ring R₃
M : Type u_4
inst✝¹⁰ : TopologicalSpace M
inst✝⁹ : AddCommGroup M
M₂ : Type u_5
inst✝⁸ : TopologicalSpace M₂
inst✝⁷ : AddCommGroup M₂
M₃ : Type u_6
inst✝⁶ : TopologicalSpace M₃
inst✝⁵ : AddCommGroup M₃
M₄ : Type u_7
inst✝⁴ : TopologicalSpace M₄
inst✝³ : AddCommGroup M₄
inst✝² : Module R M
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
f : M →SL[σ₁₂] M₂
x y : M
⊢ f (x - y) = f x - f y
state_after: no goals
Theorem: SignType.nonneg_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ 0 ≤ a ↔ a = 0 ∨ a = 1
state_after: no goals