tasksource/leandojo huggingface dataset:
Theorem: AffineSubspace.wOppSide_comm
File: Mathlib/Analysis/Convex/Side.lean

tactic: constructor
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.89985
P : Type u_3
P' : Type ?u.89991
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
⊢ WOppSide s x y ↔ WOppSide s y x

tactic: rintro ⟨p₁, hp₁, p₂, hp₂, h⟩
state_before: case mp
R : Type u_1
V : Type u_2
V' : Type ?u.89985
P : Type u_3
P' : Type ?u.89991
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
⊢ WOppSide s x y → WOppSide s y x

tactic: refine' ⟨p₂, hp₂, p₁, hp₁, _⟩
state_before: case mp.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.89985
P : Type u_3
P' : Type ?u.89991
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
⊢ WOppSide s y x

tactic: rwa [SameRay.sameRay_comm, ← sameRay_neg_iff, neg_vsub_eq_vsub_rev, neg_vsub_eq_vsub_rev]
state_before: case mp.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.89985
P : Type u_3
P' : Type ?u.89991
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
⊢ SameRay R (y -ᵥ p₂) (p₁ -ᵥ x)

tactic: rintro ⟨p₁, hp₁, p₂, hp₂, h⟩
state_before: case mpr
R : Type u_1
V : Type u_2
V' : Type ?u.89985
P : Type u_3
P' : Type ?u.89991
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
⊢ WOppSide s y x → WOppSide s x y

tactic: refine' ⟨p₂, hp₂, p₁, hp₁, _⟩
state_before: case mpr.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.89985
P : Type u_3
P' : Type ?u.89991
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (y -ᵥ p₁) (p₂ -ᵥ x)
⊢ WOppSide s x y

tactic: rwa [SameRay.sameRay_comm, ← sameRay_neg_iff, neg_vsub_eq_vsub_rev, neg_vsub_eq_vsub_rev]
state_before: case mpr.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.89985
P : Type u_3
P' : Type ?u.89991
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (y -ᵥ p₁) (p₂ -ᵥ x)
⊢ SameRay R (x -ᵥ p₂) (p₁ -ᵥ y)
Theorem: CochainComplex.cochainComplex_d_succ_succ_zero
File: Mathlib/Algebra/Homology/Augment.lean

tactic: rw [C.shape]
state_before: V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
i : ℕ
⊢ d C 0 (i + 2) = 0

tactic: simp only [ComplexShape.up_Rel, zero_add]
state_before: case a
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
i : ℕ
⊢ ¬ComplexShape.Rel (ComplexShape.up ℕ) 0 (i + 2)

tactic: exact (Nat.one_lt_succ_succ _).ne
state_before: case a
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
i : ℕ
⊢ ¬1 = i + 2
Theorem: CategoryTheory.GrothendieckTopology.close_eq_top_iff_mem
File: Mathlib/CategoryTheory/Sites/Closed.lean

tactic: constructor
state_before: C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
⊢ close J₁ S = ⊤ ↔ S ∈ sieves J₁ X

tactic: intro h
state_before: case mp
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
⊢ close J₁ S = ⊤ → S ∈ sieves J₁ X

tactic: apply J₁.transitive (J₁.top_mem X)
state_before: case mp
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : close J₁ S = ⊤
⊢ S ∈ sieves J₁ X

tactic: intro Y f hf
state_before: case mp.h
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : close J₁ S = ⊤
⊢ ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, ⊤.arrows f → Sieve.pullback f S ∈ sieves J₁ Y

tactic: change J₁.close S f
state_before: case mp.h
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : close J₁ S = ⊤
Y : C
f : Y ⟶ X
hf : ⊤.arrows f
⊢ Sieve.pullback f S ∈ sieves J₁ Y

tactic: rwa [h]
state_before: case mp.h
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
h : close J₁ S = ⊤
Y : C
f : Y ⟶ X
hf : ⊤.arrows f
⊢ (close J₁ S).arrows f

tactic: intro hS
state_before: case mpr
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
⊢ S ∈ sieves J₁ X → close J₁ S = ⊤

tactic: rw [eq_top_iff]
state_before: case mpr
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ sieves J₁ X
⊢ close J₁ S = ⊤

tactic: intro Y f _
state_before: case mpr
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ sieves J₁ X
⊢ ⊤ ≤ close J₁ S

tactic: apply J₁.pullback_stable _ hS
state_before: case mpr
C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ sieves J₁ X
Y : C
f : Y ⟶ X
a✝ : ⊤.arrows f
⊢ (close J₁ S).arrows f
Theorem: Set.two_lt_ncard_iff
File: Mathlib/Data/Set/Ncard.lean

tactic: simp_rw [ncard_eq_toFinset_card _ hs, Finset.two_lt_card_iff, Finite.mem_toFinset]
state_before: α : Type u_1
β : Type ?u.157357
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ 2 < ncard s ↔ ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c
Theorem: List.Func.get_nil
File: Mathlib/Data/List/Func.lean

tactic: cases k <;> rfl
state_before: α : Type u
β : Type v
γ : Type w
a : α
as as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
k : ℕ
⊢ get k [] = default
Theorem: LinearMapClass.ker_eq_bot
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simpa [disjoint_iff_inf_le] using @disjoint_ker' _ _ _ _ _ _ _ _ _ _ _ _ _ f ⊤
state_before: R : Type u_2
R₁ : Type ?u.1427240
R₂ : Type u_3
R₃ : Type ?u.1427246
R₄ : Type ?u.1427249
S : Type ?u.1427252
K : Type ?u.1427255
K₂ : Type ?u.1427258
M : Type u_1
M' : Type ?u.1427264
M₁ : Type ?u.1427267
M₂ : Type u_4
M₃ : Type ?u.1427273
M₄ : Type ?u.1427276
N : Type ?u.1427279
N₂ : Type ?u.1427282
ι : Type ?u.1427285
V : Type ?u.1427288
V₂ : Type ?u.1427291
inst✝⁹ : Ring R
inst✝⁸ : Ring R₂
inst✝⁷ : Ring R₃
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
f : F
⊢ ker f = ⊥ ↔ Injective ↑f
Theorem: Num.dvd_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← of_to_nat n, e]
state_before: m n : Num
x✝ : ↑m ∣ ↑n
k : ℕ
e : ↑n = ↑m * k
⊢ n = m * ↑k

tactic: simp
state_before: m n : Num
x✝ : ↑m ∣ ↑n
k : ℕ
e : ↑n = ↑m * k
⊢ ↑(↑m * k) = m * ↑k

tactic: simp [e, mul_to_nat]
state_before: m n : Num
x✝ : m ∣ n
k : Num
e : n = m * k
⊢ ↑n = ↑m * ↑k
Theorem: FirstOrder.Language.completeTheory.mem_or_not_mem
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp_rw [completeTheory, Set.mem_setOf_eq, Sentence.Realize, Formula.realize_not, or_not]
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
M : Type w
inst✝ : Structure L M
φ : Sentence L
⊢ φ ∈ completeTheory L M ∨ Formula.not φ ∈ completeTheory L M
Theorem: Nat.factorization_eq_factors_multiset
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext p
state_before: n : ℕ
⊢ factorization n = ↑Multiset.toFinsupp ↑(factors n)

tactic: simp only [Multiset.toFinsupp_apply, Multiset.mem_coe, Multiset.coe_nodup, Multiset.coe_count]
state_before: case h
n p : ℕ
⊢ ↑(factorization n) p = ↑(↑Multiset.toFinsupp ↑(factors n)) p

tactic: rw [@factors_count_eq n p]
state_before: case h
n p : ℕ
⊢ ↑(factorization n) p = count p (factors n)
Theorem: PFunctor.liftp_iff
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: constructor
state_before: P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
⊢ Liftp p x ↔ ∃ a f, x = { fst := a, snd := f } ∧ ∀ (i : B P a), p (f i)

tactic: rintro ⟨a, f, xeq, pf⟩
state_before: case mpr
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
⊢ (∃ a f, x = { fst := a, snd := f } ∧ ∀ (i : B P a), p (f i)) → Liftp p x

tactic: use ⟨a, fun i => ⟨f i, pf i⟩⟩
state_before: case mpr.intro.intro.intro
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
a : P.A
f : B P a → α
xeq : x = { fst := a, snd := f }
pf : ∀ (i : B P a), p (f i)
⊢ Liftp p x

tactic: rw [xeq]
state_before: case mpr.intro.intro.intro
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
a : P.A
f : B P a → α
xeq : x = { fst := a, snd := f }
pf : ∀ (i : B P a), p (f i)
⊢ Subtype.val <$> { fst := a, snd := fun i => { val := f i, property := (_ : p (f i)) } } = x

tactic: rfl
state_before: case mpr.intro.intro.intro
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
a : P.A
f : B P a → α
xeq : x = { fst := a, snd := f }
pf : ∀ (i : B P a), p (f i)
⊢ Subtype.val <$> { fst := a, snd := fun i => { val := f i, property := (_ : p (f i)) } } = { fst := a, snd := f }

tactic: rintro ⟨y, hy⟩
state_before: case mp
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
⊢ Liftp p x → ∃ a f, x = { fst := a, snd := f } ∧ ∀ (i : B P a), p (f i)

tactic: cases' h : y with a f
state_before: case mp.intro
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
y : Obj P (Subtype p)
hy : Subtype.val <$> y = x
⊢ ∃ a f, x = { fst := a, snd := f } ∧ ∀ (i : B P a), p (f i)

tactic: refine' ⟨a, fun i => (f i).val, _, fun i => (f i).property⟩
state_before: case mp.intro.mk
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
y : Obj P (Subtype p)
hy : Subtype.val <$> y = x
a : P.A
f : B P a → Subtype p
h : y = { fst := a, snd := f }
⊢ ∃ a f, x = { fst := a, snd := f } ∧ ∀ (i : B P a), p (f i)

tactic: rw [← hy, h, PFunctor.map_eq]
state_before: case mp.intro.mk
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
y : Obj P (Subtype p)
hy : Subtype.val <$> y = x
a : P.A
f : B P a → Subtype p
h : y = { fst := a, snd := f }
⊢ x = { fst := a, snd := fun i => ↑(f i) }

tactic: congr
state_before: case mp.intro.mk
P : PFunctor
α : Type u
p : α → Prop
x : Obj P α
y : Obj P (Subtype p)
hy : Subtype.val <$> y = x
a : P.A
f : B P a → Subtype p
h : y = { fst := a, snd := f }
⊢ { fst := a, snd := Subtype.val ∘ f } = { fst := a, snd := fun i => ↑(f i) }
Theorem: Real.young_inequality_of_nonneg
File: Mathlib/Analysis/MeanInequalities.lean

tactic: simpa [← rpow_mul, ha, hb, hpq.ne_zero, hpq.symm.ne_zero, _root_.div_eq_inv_mul] using
  geom_mean_le_arith_mean2_weighted hpq.one_div_nonneg hpq.symm.one_div_nonneg
    (rpow_nonneg_of_nonneg ha p) (rpow_nonneg_of_nonneg hb q) hpq.inv_add_inv_conj
state_before: ι : Type u
s : Finset ι
a b p q : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hpq : IsConjugateExponent p q
⊢ a * b ≤ a ^ p / p + b ^ q / q
Theorem: CategoryTheory.Functor.preservesMonomorphisms_of_adjunction
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: intro Z g h H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : D
f : X ⟶ Y
hf : Mono f
⊢ ∀ {Z : C} (g h : Z ⟶ G.obj X), g ≫ G.map f = h ≫ G.map f → g = h

tactic: replace H := congr_arg (adj.homEquiv Z Y).symm H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : D
f : X ⟶ Y
hf : Mono f
Z : C
g h : Z ⟶ G.obj X
H : g ≫ G.map f = h ≫ G.map f
⊢ g = h

tactic: rwa [adj.homEquiv_naturality_right_symm, adj.homEquiv_naturality_right_symm, cancel_mono,
  Equiv.apply_eq_iff_eq] at H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : D
f : X ⟶ Y
hf : Mono f
Z : C
g h : Z ⟶ G.obj X
H : ↑(Adjunction.homEquiv adj Z Y).symm (g ≫ G.map f) = ↑(Adjunction.homEquiv adj Z Y).symm (h ≫ G.map f)
⊢ g = h
Theorem: UniqueFactorizationMonoid.normalizedFactors_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: induction' n with n ih
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
⊢ normalizedFactors (x ^ n) = n • normalizedFactors x

tactic: by_cases h0 : x = 0
state_before: case succ
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
⊢ normalizedFactors (x ^ Nat.succ n) = Nat.succ n • normalizedFactors x

tactic: rw [pow_succ, succ_nsmul, normalizedFactors_mul h0 (pow_ne_zero _ h0), ih]
state_before: case neg
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
h0 : ¬x = 0
⊢ normalizedFactors (x ^ Nat.succ n) = Nat.succ n • normalizedFactors x

tactic: simp
state_before: case zero
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
⊢ normalizedFactors (x ^ Nat.zero) = Nat.zero • normalizedFactors x

tactic: simp [h0, zero_pow n.succ_pos, smul_zero]
state_before: case pos
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
h0 : x = 0
⊢ normalizedFactors (x ^ Nat.succ n) = Nat.succ n • normalizedFactors x
Theorem: MvPolynomial.induction_on'
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rwa [monomial_zero] at this
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
P : MvPolynomial σ R → Prop
p : MvPolynomial σ R
h1 : ∀ (u : σ →₀ ℕ) (a : R), P (↑(monomial u) a)
h2 : ∀ (p q : MvPolynomial σ R), P p → P q → P (p + q)
this : P (↑(monomial 0) 0)
⊢ P 0
Theorem: Set.image_restrict
File: Mathlib/Data/Set/Function.lean

tactic: rw [restrict_eq, image_comp, image_preimage_eq_inter_range, Subtype.range_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1357
ι : Sort ?u.1360
π : α → Type ?u.1365
f : α → β
s t : Set α
⊢ restrict s f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s)
Theorem: MonoidAlgebra.liftNC_one
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp [one_def]
state_before: k : Type u₁
G : Type u₂
R : Type u_2
inst✝³ : NonAssocSemiring R
inst✝² : Semiring k
inst✝¹ : One G
g_hom : Type u_1
inst✝ : OneHomClass g_hom G R
f : k →+* R
g : g_hom
⊢ ↑(liftNC ↑f ↑g) 1 = 1
Theorem: HahnSeries.coeff_eq_zero_of_lt_order
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hi : i < order x
⊢ coeff x i = 0

tactic: contrapose! hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hi : i < order x
hx : x ≠ 0
⊢ coeff x i = 0

tactic: rw [← mem_support] at hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : coeff x i ≠ 0
⊢ ¬i < order x

tactic: rw [order_of_ne hx]
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ support x
⊢ ¬i < order x

tactic: exact Set.IsWf.not_lt_min _ _ hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ support x
⊢ ¬i < Set.IsWf.min (_ : Set.IsWf (support x)) (_ : Set.Nonempty (support x))

tactic: simp
state_before: case inl
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
i : Γ
hi : i < order 0
⊢ coeff 0 i = 0
Theorem: LinearMap.extendTo𝕜'_apply_re
File: Mathlib/Analysis/NormedSpace/Extend.lean

tactic: simp only [extendTo𝕜'_apply, map_sub, MulZeroClass.zero_mul, MulZeroClass.mul_zero, sub_zero,
  isROrC_simps]
state_before: 𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : Module ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →ₗ[ℝ] ℝ
x : F
⊢ ↑re (↑(extendTo𝕜' fr) x) = ↑fr x
Theorem: SimpleGraph.Walk.darts_nodup_of_support_nodup
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp
| cons _ p' ih =>
  simp only [darts_cons, support_cons, List.nodup_cons] at h ⊢
  exact ⟨fun h' => h.1 (dart_fst_mem_support_of_mem_darts p' h'), ih h.2⟩
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
h : List.Nodup (support p)
⊢ List.Nodup (darts p)

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
h : List.Nodup (support nil)
⊢ List.Nodup (darts nil)

tactic: simp only [darts_cons, support_cons, List.nodup_cons] at h ⊢
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : List.Nodup (support p') → List.Nodup (darts p')
h : List.Nodup (support (cons h✝ p'))
⊢ List.Nodup (darts (cons h✝ p'))

tactic: exact ⟨fun h' => h.1 (dart_fst_mem_support_of_mem_darts p' h'), ih h.2⟩
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : List.Nodup (support p') → List.Nodup (darts p')
h : ¬u✝ ∈ support p' ∧ List.Nodup (support p')
⊢ ¬{ toProd := (u✝, v✝), is_adj := h✝ } ∈ darts p' ∧ List.Nodup (darts p')
Theorem: inv_mul_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← h, mul_inv_cancel_left]
state_before: α : Type ?u.54779
β : Type ?u.54782
G : Type u_1
inst✝ : Group G
a b c d : G
h : a⁻¹ * b = c
⊢ b = a * c

tactic: rw [h, inv_mul_cancel_left]
state_before: α : Type ?u.54779
β : Type ?u.54782
G : Type u_1
inst✝ : Group G
a b c d : G
h : b = a * c
⊢ a⁻¹ * b = c
Theorem: GaloisConnection.isLUB_l_image
File: Mathlib/Order/GaloisConnection.lean

tactic: rwa [gc.upperBounds_l_image] at hb
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.9528
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
s : Set α
a : α
h : IsLUB s a
b : β
hb : b ∈ upperBounds (l '' s)
⊢ u b ∈ upperBounds s
Theorem: Set.mem_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [mem_iUnion]
state_before: α : Type ?u.42510
β : Type ?u.42513
γ : Type u_1
ι : Sort u_2
ι' : Sort ?u.42522
ι₂ : Sort ?u.42525
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.42535
κ₂ : ι → Sort ?u.42540
κ' : ι' → Sort ?u.42545
x : γ
s : (i : ι) → κ i → Set γ
⊢ (x ∈ ⋃ (i : ι) (j : κ i), s i j) ↔ ∃ i j, x ∈ s i j
Theorem: QuadraticForm.polar_smul_right_of_tower
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← IsScalarTower.algebraMap_smul R a y, polar_smul_right, Algebra.smul_def]
state_before: S : Type u_3
R : Type u_1
R₁ : Type ?u.194332
M : Type u_2
inst✝⁷ : Ring R
inst✝⁶ : CommRing R₁
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Module S M
inst✝ : IsScalarTower S R M
a : S
x y : M
⊢ polar (↑Q) x (a • y) = a • polar (↑Q) x y
Theorem: Commute.orderOf_mul_eq_mul_orderOf_of_coprime
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf, ← comp_mul_left]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : _root_.Commute x y
hco : coprime (orderOf x) (orderOf y)
⊢ orderOf (x * y) = orderOf x * orderOf y

tactic: exact h.function_commute_mul_left.minimalPeriod_of_comp_eq_mul_of_coprime hco
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : _root_.Commute x y
hco : coprime (orderOf x) (orderOf y)
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 = orderOf x * orderOf y
Theorem: Matrix.blockDiagonal_tsum
File: Mathlib/Topology/Instances/Matrix.lean

tactic: by_cases hf : Summable f
state_before: X : Type u_5
α : Type ?u.94238
l : Type ?u.94241
m : Type u_3
n : Type u_4
p : Type u_1
S : Type ?u.94253
R : Type u_2
m' : l → Type ?u.94261
n' : l → Type ?u.94266
inst✝⁵ : Semiring α
inst✝⁴ : AddCommMonoid R
inst✝³ : TopologicalSpace R
inst✝² : Module α R
inst✝¹ : DecidableEq p
inst✝ : T2Space R
f : X → p → Matrix m n R
⊢ blockDiagonal (∑' (x : X), f x) = ∑' (x : X), blockDiagonal (f x)

tactic: exact hf.hasSum.matrix_blockDiagonal.tsum_eq.symm
state_before: case pos
X : Type u_5
α : Type ?u.94238
l : Type ?u.94241
m : Type u_3
n : Type u_4
p : Type u_1
S : Type ?u.94253
R : Type u_2
m' : l → Type ?u.94261
n' : l → Type ?u.94266
inst✝⁵ : Semiring α
inst✝⁴ : AddCommMonoid R
inst✝³ : TopologicalSpace R
inst✝² : Module α R
inst✝¹ : DecidableEq p
inst✝ : T2Space R
f : X → p → Matrix m n R
hf : Summable f
⊢ blockDiagonal (∑' (x : X), f x) = ∑' (x : X), blockDiagonal (f x)

tactic: have hft := summable_matrix_blockDiagonal.not.mpr hf
state_before: case neg
X : Type u_5
α : Type ?u.94238
l : Type ?u.94241
m : Type u_3
n : Type u_4
p : Type u_1
S : Type ?u.94253
R : Type u_2
m' : l → Type ?u.94261
n' : l → Type ?u.94266
inst✝⁵ : Semiring α
inst✝⁴ : AddCommMonoid R
inst✝³ : TopologicalSpace R
inst✝² : Module α R
inst✝¹ : DecidableEq p
inst✝ : T2Space R
f : X → p → Matrix m n R
hf : ¬Summable f
⊢ blockDiagonal (∑' (x : X), f x) = ∑' (x : X), blockDiagonal (f x)

tactic: rw [tsum_eq_zero_of_not_summable hf, tsum_eq_zero_of_not_summable hft]
state_before: case neg
X : Type u_5
α : Type ?u.94238
l : Type ?u.94241
m : Type u_3
n : Type u_4
p : Type u_1
S : Type ?u.94253
R : Type u_2
m' : l → Type ?u.94261
n' : l → Type ?u.94266
inst✝⁵ : Semiring α
inst✝⁴ : AddCommMonoid R
inst✝³ : TopologicalSpace R
inst✝² : Module α R
inst✝¹ : DecidableEq p
inst✝ : T2Space R
f : X → p → Matrix m n R
hf : ¬Summable f
hft : ¬Summable fun x => blockDiagonal (f x)
⊢ blockDiagonal (∑' (x : X), f x) = ∑' (x : X), blockDiagonal (f x)

tactic: exact blockDiagonal_zero
state_before: case neg
X : Type u_5
α : Type ?u.94238
l : Type ?u.94241
m : Type u_3
n : Type u_4
p : Type u_1
S : Type ?u.94253
R : Type u_2
m' : l → Type ?u.94261
n' : l → Type ?u.94266
inst✝⁵ : Semiring α
inst✝⁴ : AddCommMonoid R
inst✝³ : TopologicalSpace R
inst✝² : Module α R
inst✝¹ : DecidableEq p
inst✝ : T2Space R
f : X → p → Matrix m n R
hf : ¬Summable f
hft : ¬Summable fun x => blockDiagonal (f x)
⊢ blockDiagonal 0 = 0
Theorem: Equiv.Perm.sign_permCongr
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
e : α ≃ β
p : Perm α
⊢ ∀ (x : β), ↑e.symm (↑(↑(permCongr e) p) x) = ↑p (↑e.symm x)
Theorem: Num.zneg_toZNumNeg
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> rfl
state_before: α : Type ?u.446609
n : Num
⊢ -toZNumNeg n = toZNum n
Theorem: mul_invOf_self_assoc'
File: Mathlib/Algebra/Invertible.lean

tactic: rw [← mul_assoc, mul_invOf_self, one_mul]
state_before: α : Type u
inst✝ : Monoid α
a b : α
x✝ : Invertible a
⊢ a * (⅟a * b) = b