1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MulChar.IsQuadratic.pow_char
File: Mathlib/NumberTheory/MulChar/Basic.lean

tactic: ext x
state_before: R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
⊢ χ ^ p = χ
state_after: case h
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
⊢ (χ ^ p) ↑x = χ ↑x

tactic: rw [pow_apply_coe]
state_before: case h
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
⊢ (χ ^ p) ↑x = χ ↑x
state_after: case h
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
⊢ χ ↑x ^ p = χ ↑x

tactic: rcases hχ x with (hx | hx | hx) <;> rw [hx]
state_before: case h
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
⊢ χ ↑x ^ p = χ ↑x
state_after: case h.inl
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : χ ↑x = 0
⊢ 0 ^ p = 0

case h.inr.inl
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : χ ↑x = 1
⊢ 1 ^ p = 1

case h.inr.inr
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : χ ↑x = -1
⊢ (-1) ^ p = -1

tactic: rw [zero_pow (@Fact.out p.Prime).ne_zero]
state_before: case h.inl
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : χ ↑x = 0
⊢ 0 ^ p = 0
state_after: no goals

tactic: rw [one_pow]
state_before: case h.inr.inl
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : χ ↑x = 1
⊢ 1 ^ p = 1
state_after: no goals

tactic: exact CharP.neg_one_pow_char R' p
state_before: case h.inr.inr
R : Type u_1
inst✝³ : CommMonoid R
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R' p
x : Rˣ
hx : χ ↑x = -1
⊢ (-1) ^ p = -1
state_after: no goals
Theorem: Commensurable.commensurable_inv
File: Mathlib/GroupTheory/Commensurable.lean

tactic: rw [commensurable_conj, inv_smul_smul]
state_before: G : Type u_1
inst✝ : Group G
H : Subgroup G
g : ConjAct G
⊢ Commensurable (g • H) H ↔ Commensurable H (g⁻¹ • H)
state_after: no goals
Theorem: PowerSeries.ext
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← coeff_def]
state_before: R : Type u_1
inst✝ : Semiring R
φ ψ : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) φ = (coeff R n) ψ
n : Unit →₀ ℕ
⊢ (MvPowerSeries.coeff R n) φ = (MvPowerSeries.coeff R n) ψ
state_after: R : Type u_1
inst✝ : Semiring R
φ ψ : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) φ = (coeff R n) ψ
n : Unit →₀ ℕ
⊢ (coeff R ?m.9994) φ = (coeff R ?m.9994) ψ

R : Type u_1
inst✝ : Semiring R
φ ψ : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) φ = (coeff R n) ψ
n : Unit →₀ ℕ
⊢ n () = ?m.9994

R : Type u_1
inst✝ : Semiring R
φ ψ : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) φ = (coeff R n) ψ
n : Unit →₀ ℕ
⊢ ℕ

tactic: rfl
state_before: R : Type u_1
inst✝ : Semiring R
φ ψ : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) φ = (coeff R n) ψ
n : Unit →₀ ℕ
⊢ n () = ?m.9994

R : Type u_1
inst✝ : Semiring R
φ ψ : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) φ = (coeff R n) ψ
n : Unit →₀ ℕ
⊢ ℕ
state_after: no goals

tactic: apply h
state_before: R : Type u_1
inst✝ : Semiring R
φ ψ : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) φ = (coeff R n) ψ
n : Unit →₀ ℕ
⊢ (coeff R ?m.9994) φ = (coeff R ?m.9994) ψ
state_after: no goals
Theorem: summable_norm_pow_mul_geometric_of_norm_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rcases exists_between hr with ⟨r', hrr', h⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝ : NormedRing R
k : ℕ
r : R
hr : ‖r‖ < 1
⊢ Summable fun n => ‖↑n ^ k * r ^ n‖
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝ : NormedRing R
k : ℕ
r : R
hr : ‖r‖ < 1
r' : ℝ
hrr' : ‖r‖ < r'
h : r' < 1
⊢ Summable fun n => ‖↑n ^ k * r ^ n‖

tactic: exact summable_of_isBigO_nat (summable_geometric_of_lt_one ((norm_nonneg _).trans hrr'.le) h)
  (isLittleO_pow_const_mul_const_pow_const_pow_of_norm_lt _ hrr').isBigO.norm_left
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝ : NormedRing R
k : ℕ
r : R
hr : ‖r‖ < 1
r' : ℝ
hrr' : ‖r‖ < r'
h : r' < 1
⊢ Summable fun n => ‖↑n ^ k * r ^ n‖
state_after: no goals
Theorem: CochainComplex.mappingCone.inr_desc
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: aesop_cat
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cochain F K (-1)
β : G ⟶ K
eq : δ (-1) 0 α = Cochain.ofHom (φ ≫ β)
⊢ inr φ ≫ desc φ α β eq = β
state_after: no goals
Theorem: Equiv.Perm.isCycle_cycleOf
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

tactic: rwa [SameCycle.rfl.cycleOf_apply]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : f x ≠ x
⊢ (f.cycleOf x) x ≠ x
state_after: no goals

tactic: rw [cycleOf_zpow_apply_self, hi]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : f x ≠ x
this : (f.cycleOf x) x ≠ x
y : α
h : (f.cycleOf x) y ≠ y
hxy : f.SameCycle x y
i : ℤ
hi : (f ^ i) x = y
⊢ (f.cycleOf x ^ i) x = y
state_after: no goals

tactic: rw [cycleOf_apply_of_not_sameCycle hxy] at h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : f x ≠ x
this : (f.cycleOf x) x ≠ x
y : α
h : (f.cycleOf x) y ≠ y
hxy : ¬f.SameCycle x y
⊢ (f.cycleOf x).SameCycle x y
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : f x ≠ x
this : (f.cycleOf x) x ≠ x
y : α
h : y ≠ y
hxy : ¬f.SameCycle x y
⊢ (f.cycleOf x).SameCycle x y

tactic: exact (h rfl).elim
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : f x ≠ x
this : (f.cycleOf x) x ≠ x
y : α
h : y ≠ y
hxy : ¬f.SameCycle x y
⊢ (f.cycleOf x).SameCycle x y
state_after: no goals
Theorem: Set.preimage_liftCover
File: Mathlib/Data/Set/UnionLift.lean

tactic: change (iUnionLift S f hf univ hS.symm.subset ∘ fun a => ⟨a, mem_univ a⟩) ⁻¹' t = _
state_before: α : Type u_1
ι : Sort u_3
β : Type u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
hS : iUnion S = univ
t : Set β
⊢ liftCover S f hf hS ⁻¹' t = ⋃ i, Subtype.val '' (f i ⁻¹' t)
state_after: α : Type u_1
ι : Sort u_3
β : Type u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
hS : iUnion S = univ
t : Set β
⊢ (iUnionLift S f hf univ ⋯ ∘ fun a => ⟨a, ⋯⟩) ⁻¹' t = ⋃ i, Subtype.val '' (f i ⁻¹' t)

tactic: rw [preimage_comp, preimage_iUnionLift]
state_before: α : Type u_1
ι : Sort u_3
β : Type u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
hS : iUnion S = univ
t : Set β
⊢ (iUnionLift S f hf univ ⋯ ∘ fun a => ⟨a, ⋯⟩) ⁻¹' t = ⋃ i, Subtype.val '' (f i ⁻¹' t)
state_after: α : Type u_1
ι : Sort u_3
β : Type u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
hS : iUnion S = univ
t : Set β
⊢ (fun a => ⟨a, ⋯⟩) ⁻¹' (inclusion ⋯ ⁻¹' ⋃ i, inclusion ⋯ '' (f i ⁻¹' t)) = ⋃ i, Subtype.val '' (f i ⁻¹' t)

tactic: ext
state_before: α : Type u_1
ι : Sort u_3
β : Type u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
hS : iUnion S = univ
t : Set β
⊢ (fun a => ⟨a, ⋯⟩) ⁻¹' (inclusion ⋯ ⁻¹' ⋃ i, inclusion ⋯ '' (f i ⁻¹' t)) = ⋃ i, Subtype.val '' (f i ⁻¹' t)
state_after: case h
α : Type u_1
ι : Sort u_3
β : Type u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
hS : iUnion S = univ
t : Set β
x✝ : α
⊢ x✝ ∈ (fun a => ⟨a, ⋯⟩) ⁻¹' (inclusion ⋯ ⁻¹' ⋃ i, inclusion ⋯ '' (f i ⁻¹' t)) ↔ x✝ ∈ ⋃ i, Subtype.val '' (f i ⁻¹' t)

tactic: simp
state_before: case h
α : Type u_1
ι : Sort u_3
β : Type u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
hS : iUnion S = univ
t : Set β
x✝ : α
⊢ x✝ ∈ (fun a => ⟨a, ⋯⟩) ⁻¹' (inclusion ⋯ ⁻¹' ⋃ i, inclusion ⋯ '' (f i ⁻¹' t)) ↔ x✝ ∈ ⋃ i, Subtype.val '' (f i ⁻¹' t)
state_after: no goals
Theorem: PythagoreanTriple.isPrimitiveClassified_of_coprime
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: by_cases hz : 0 < z
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ h.IsPrimitiveClassified
state_after: case pos
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : 0 < z
⊢ h.IsPrimitiveClassified

case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
⊢ h.IsPrimitiveClassified

tactic: have h' : PythagoreanTriple x y (-z) := by simpa [PythagoreanTriple, neg_mul_neg] using h.eq
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
⊢ h.IsPrimitiveClassified
state_after: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ h.IsPrimitiveClassified

tactic: apply h'.isPrimitiveClassified_of_coprime_of_pos hc
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ h.IsPrimitiveClassified
state_after: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ 0 < -z

tactic: apply lt_of_le_of_ne _ (h'.ne_zero_of_coprime hc).symm
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ 0 < -z
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ 0 ≤ -z

tactic: exact le_neg.mp (not_lt.mp hz)
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ 0 ≤ -z
state_after: no goals

tactic: exact h.isPrimitiveClassified_of_coprime_of_pos hc hz
state_before: case pos
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : 0 < z
⊢ h.IsPrimitiveClassified
state_after: no goals

tactic: simpa [PythagoreanTriple, neg_mul_neg] using h.eq
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hz : ¬0 < z
⊢ PythagoreanTriple x y (-z)
state_after: no goals
Theorem: Polynomial.divX_C
File: Mathlib/Algebra/Polynomial/Inductions.lean

tactic: simp [coeff_divX, coeff_C, Finsupp.single_eq_of_ne _]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : R
n : ℕ
⊢ (C a).divX.coeff n = coeff 0 n
state_after: no goals
Theorem: Turing.Tape.move_right_mk'
File: Mathlib/Computability/TuringMachine.lean

tactic: simp only [Tape.move, Tape.mk', ListBlank.head_cons, eq_self_iff_true, ListBlank.cons_head_tail,
  and_self_iff, ListBlank.tail_cons]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
L R : ListBlank Γ
⊢ move Dir.right (mk' L R) = mk' (ListBlank.cons R.head L) R.tail
state_after: no goals
Theorem: Multiset.support_sum_subset
File: Mathlib/Data/Finsupp/BigOperators.lean

tactic: induction s using Quot.inductionOn
state_before: ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddCommMonoid M
s : Multiset (ι →₀ M)
⊢ s.sum.support ⊆ (map Finsupp.support s).sup
state_after: case h
ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddCommMonoid M
a✝ : List (ι →₀ M)
⊢ (sum (Quot.mk Setoid.r a✝)).support ⊆ (map Finsupp.support (Quot.mk Setoid.r a✝)).sup

tactic: simpa only [Multiset.quot_mk_to_coe'', Multiset.sum_coe, Multiset.map_coe, Multiset.sup_coe,
  List.foldr_map] using List.support_sum_subset _
state_before: case h
ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddCommMonoid M
a✝ : List (ι →₀ M)
⊢ (sum (Quot.mk Setoid.r a✝)).support ⊆ (map Finsupp.support (Quot.mk Setoid.r a✝)).sup
state_after: no goals
Theorem: zpow_pos_of_pos
File: Mathlib/Algebra/Order/Field/Defs.lean

tactic: rw [zpow_natCast]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 < a
n : ℕ
⊢ 0 < a ^ ↑n
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 < a
n : ℕ
⊢ 0 < a ^ n

tactic: exact pow_pos ha _
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 < a
n : ℕ
⊢ 0 < a ^ n
state_after: no goals

tactic: rw [zpow_neg, inv_pos, zpow_natCast]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 < a
n : ℕ
⊢ 0 < a ^ (-↑(n + 1))
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 < a
n : ℕ
⊢ 0 < a ^ (n + 1)

tactic: exact pow_pos ha _
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 < a
n : ℕ
⊢ 0 < a ^ (n + 1)
state_after: no goals
Theorem: Ctop.Realizer.mem_nhds
File: Mathlib/Data/Analysis/Topology.lean

tactic: have := @mem_nhds_toTopsp _ _ F.F s a
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
T : TopologicalSpace α
F : Realizer α
s : Set α
a : α
⊢ s ∈ 𝓝 a ↔ ∃ b, a ∈ F.F.f b ∧ F.F.f b ⊆ s
state_after: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
T : TopologicalSpace α
F : Realizer α
s : Set α
a : α
this : s ∈ 𝓝 a ↔ ∃ b, a ∈ F.F.f b ∧ F.F.f b ⊆ s
⊢ s ∈ 𝓝 a ↔ ∃ b, a ∈ F.F.f b ∧ F.F.f b ⊆ s

tactic: rwa [F.eq] at this
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
T : TopologicalSpace α
F : Realizer α
s : Set α
a : α
this : s ∈ 𝓝 a ↔ ∃ b, a ∈ F.F.f b ∧ F.F.f b ⊆ s
⊢ s ∈ 𝓝 a ↔ ∃ b, a ∈ F.F.f b ∧ F.F.f b ⊆ s
state_after: no goals
Theorem: Ordinal.sup_eq_lsub_iff_lt_sup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
h : sup f = lsub f
i : ι
⊢ f i < sup f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
h : sup f = lsub f
i : ι
⊢ f i < lsub f

tactic: apply lt_lsub
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
h : sup f = lsub f
i : ι
⊢ f i < lsub f
state_after: no goals
Theorem: Vector.mem_succ_iff
File: Mathlib/Data/Vector/Mem.lean

tactic: obtain ⟨a', v', h⟩ := exists_eq_cons v
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
v : Vector α (n + 1)
⊢ a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList
state_after: case intro.intro
α : Type u_1
β : Type u_2
n : ℕ
a a'✝ : α
v : Vector α (n + 1)
a' : α
v' : Vector α n
h : v = a' ::ᵥ v'
⊢ a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList

tactic: simp_rw [h, Vector.mem_cons_iff, Vector.head_cons, Vector.tail_cons]
state_before: case intro.intro
α : Type u_1
β : Type u_2
n : ℕ
a a'✝ : α
v : Vector α (n + 1)
a' : α
v' : Vector α n
h : v = a' ::ᵥ v'
⊢ a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList
state_after: no goals
Theorem: FreeGroup.map.unique
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: rintro ⟨L⟩
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
⊢ ∀ {x : FreeGroup α}, g x = (map f) x
state_after: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
x✝ : FreeGroup α
L : List (α × Bool)
⊢ g (Quot.mk Red.Step L) = (map f) (Quot.mk Red.Step L)

tactic: exact List.recOn L g.map_one fun ⟨x, b⟩ t (ih : g (FreeGroup.mk t) = map f (FreeGroup.mk t)) =>
  Bool.recOn b
    (show g ((FreeGroup.of x)⁻¹ * FreeGroup.mk t) =
        FreeGroup.map f ((FreeGroup.of x)⁻¹ * FreeGroup.mk t) by
      simp [g.map_mul, g.map_inv, hg, ih])
    (show g (FreeGroup.of x * FreeGroup.mk t) =
        FreeGroup.map f (FreeGroup.of x * FreeGroup.mk t) by simp [g.map_mul, hg, ih])
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
x✝ : FreeGroup α
L : List (α × Bool)
⊢ g (Quot.mk Red.Step L) = (map f) (Quot.mk Red.Step L)
state_after: no goals

tactic: simp [g.map_mul, g.map_inv, hg, ih]
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝² y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
x✝¹ : FreeGroup α
L : List (α × Bool)
x✝ : α × Bool
t : List (α × Bool)
ih : g (FreeGroup.mk t) = (map f) (FreeGroup.mk t)
x : α
b : Bool
⊢ g ((FreeGroup.of x)⁻¹ * FreeGroup.mk t) = (map f) ((FreeGroup.of x)⁻¹ * FreeGroup.mk t)
state_after: no goals

tactic: simp [g.map_mul, hg, ih]
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝² y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
x✝¹ : FreeGroup α
L : List (α × Bool)
x✝ : α × Bool
t : List (α × Bool)
ih : g (FreeGroup.mk t) = (map f) (FreeGroup.mk t)
x : α
b : Bool
⊢ g (FreeGroup.of x * FreeGroup.mk t) = (map f) (FreeGroup.of x * FreeGroup.mk t)
state_after: no goals
Theorem: Nat.matrixOf_eval_descPochhammer_eq_mul_matrixOf_choose
File: Mathlib/Data/Nat/Factorial/SuperFactorial.lean

tactic: convert Matrix.det_mul_row (fun (i : Fin n) => ((Nat.factorial (i : ℕ)):ℤ)) _
state_before: n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
⊢ (Matrix.of fun i j => Polynomial.eval (↑(v i)) (descPochhammer ℤ ↑j)).det =
    ↑(∏ i : Fin n, (↑i)!) * (Matrix.of fun i j => ↑((v i).choose ↑j)).det
state_after: case h.e'_2.h.e'_6.h.e'_6.h.h
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
x✝¹ x✝ : Fin n
⊢ Polynomial.eval (↑(v x✝¹)) (descPochhammer ℤ ↑x✝) = ↑(↑x✝)! * Matrix.of (fun i j => ↑((v i).choose ↑j)) x✝¹ x✝

case h.e'_3.h.e'_5
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
⊢ ↑(∏ i : Fin n, (↑i)!) = ∏ i : Fin n, ↑(↑i)!

tactic: rw [Matrix.of_apply, descPochhammer_eval_eq_descFactorial ℤ _ _]
state_before: case h.e'_2.h.e'_6.h.e'_6.h.h
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
x✝¹ x✝ : Fin n
⊢ Polynomial.eval (↑(v x✝¹)) (descPochhammer ℤ ↑x✝) = ↑(↑x✝)! * Matrix.of (fun i j => ↑((v i).choose ↑j)) x✝¹ x✝
state_after: case h.e'_2.h.e'_6.h.e'_6.h.h
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
x✝¹ x✝ : Fin n
⊢ ↑((v x✝¹).descFactorial ↑x✝) = ↑(↑x✝)! * ↑((v x✝¹).choose ↑x✝)

tactic: congr
state_before: case h.e'_2.h.e'_6.h.e'_6.h.h
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
x✝¹ x✝ : Fin n
⊢ ↑((v x✝¹).descFactorial ↑x✝) = ↑(↑x✝)! * ↑((v x✝¹).choose ↑x✝)
state_after: case h.e'_2.h.e'_6.h.e'_6.h.h.e_a
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
x✝¹ x✝ : Fin n
⊢ (v x✝¹).descFactorial ↑x✝ = (↑x✝)! * (v x✝¹).choose ↑x✝

tactic: exact Nat.descFactorial_eq_factorial_mul_choose _ _
state_before: case h.e'_2.h.e'_6.h.e'_6.h.h.e_a
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
x✝¹ x✝ : Fin n
⊢ (v x✝¹).descFactorial ↑x✝ = (↑x✝)! * (v x✝¹).choose ↑x✝
state_after: no goals

tactic: rw [Nat.cast_prod]
state_before: case h.e'_3.h.e'_5
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → ℕ
⊢ ↑(∏ i : Fin n, (↑i)!) = ∏ i : Fin n, ↑(↑i)!
state_after: no goals
Theorem: HurwitzZeta.oddKernel_zero
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: simpa only [neg_zero, eq_neg_self_iff] using oddKernel_neg 0 x
state_before: x : ℝ
⊢ oddKernel 0 x = 0
state_after: no goals
Theorem: SzemerediRegularity.coe_m_add_one_pos
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

tactic: positivity
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
P : Finpartition univ
u : Finset α
ε : ℝ
⊢ 0 < ↑m + 1
state_after: no goals
Theorem: Real.sqrtTwoAddSeries_step_up
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: refine le_trans ?_ hz
state_before: c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
⊢ (↑a / ↑b).sqrtTwoAddSeries (n + 1) ≤ z
state_after: c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
⊢ (↑a / ↑b).sqrtTwoAddSeries (n + 1) ≤ (↑c / ↑d).sqrtTwoAddSeries n

tactic: rw [sqrtTwoAddSeries_succ]
state_before: c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
⊢ (↑a / ↑b).sqrtTwoAddSeries (n + 1) ≤ (↑c / ↑d).sqrtTwoAddSeries n
state_after: c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
⊢ (√(2 + ↑a / ↑b)).sqrtTwoAddSeries n ≤ (↑c / ↑d).sqrtTwoAddSeries n

tactic: apply sqrtTwoAddSeries_monotone_left
state_before: c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
⊢ (√(2 + ↑a / ↑b)).sqrtTwoAddSeries n ≤ (↑c / ↑d).sqrtTwoAddSeries n
state_after: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
⊢ √(2 + ↑a / ↑b) ≤ ↑c / ↑d

tactic: have hb' : 0 < (b : ℝ) := Nat.cast_pos.2 hb
state_before: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
⊢ √(2 + ↑a / ↑b) ≤ ↑c / ↑d
state_after: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
hb' : 0 < ↑b
⊢ √(2 + ↑a / ↑b) ≤ ↑c / ↑d

tactic: have hd' : 0 < (d : ℝ) := Nat.cast_pos.2 hd
state_before: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
hb' : 0 < ↑b
⊢ √(2 + ↑a / ↑b) ≤ ↑c / ↑d
state_after: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
hb' : 0 < ↑b
hd' : 0 < ↑d
⊢ √(2 + ↑a / ↑b) ≤ ↑c / ↑d

tactic: rw [sqrt_le_left (div_nonneg c.cast_nonneg d.cast_nonneg), div_pow,
  add_div_eq_mul_add_div _ _ (ne_of_gt hb'), div_le_div_iff hb' (pow_pos hd' _)]
state_before: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
hb' : 0 < ↑b
hd' : 0 < ↑d
⊢ √(2 + ↑a / ↑b) ≤ ↑c / ↑d
state_after: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
hb' : 0 < ↑b
hd' : 0 < ↑d
⊢ (2 * ↑b + ↑a) * ↑d ^ 2 ≤ ↑c ^ 2 * ↑b

tactic: exact mod_cast h
state_before: case h
c d a b n : ℕ
z : ℝ
hz : (↑c / ↑d).sqrtTwoAddSeries n ≤ z
hb : 0 < b
hd : 0 < d
h : (2 * b + a) * d ^ 2 ≤ c ^ 2 * b
hb' : 0 < ↑b
hd' : 0 < ↑d
⊢ (2 * ↑b + ↑a) * ↑d ^ 2 ≤ ↑c ^ 2 * ↑b
state_after: no goals