tasksource/leandojo huggingface dataset:
Theorem: Finset.sup_product_left
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp only [le_antisymm_iff, Finset.sup_le_iff, mem_product, and_imp, Prod.forall]
state_before: F : Type ?u.55319
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.55331
κ : Type ?u.55334
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a : α
s : Finset β
t : Finset γ
f : β × γ → α
⊢ sup (s ×ˢ t) f = sup s fun i => sup t fun i' => f (i, i')

tactic: refine ⟨fun b c hb hc => ?_, fun b hb c hc => ?_⟩
state_before: F : Type ?u.55319
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.55331
κ : Type ?u.55334
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a : α
s : Finset β
t : Finset γ
f : β × γ → α
⊢ (∀ (a : β) (b : γ), a ∈ s → b ∈ t → f (a, b) ≤ sup s fun i => sup t fun i' => f (i, i')) ∧
    ∀ (b : β), b ∈ s → ∀ (b_1 : γ), b_1 ∈ t → f (b, b_1) ≤ sup (s ×ˢ t) f

tactic: refine (le_sup hb).trans' ?_
state_before: case refine_1
F : Type ?u.55319
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.55331
κ : Type ?u.55334
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a : α
s : Finset β
t : Finset γ
f : β × γ → α
b : β
c : γ
hb : b ∈ s
hc : c ∈ t
⊢ f (b, c) ≤ sup s fun i => sup t fun i' => f (i, i')

tactic: exact @le_sup _ _ _ _ _ (fun c => f (b, c)) c hc
state_before: case refine_1
F : Type ?u.55319
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.55331
κ : Type ?u.55334
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a : α
s : Finset β
t : Finset γ
f : β × γ → α
b : β
c : γ
hb : b ∈ s
hc : c ∈ t
⊢ f (b, c) ≤ sup t fun i' => f (b, i')

tactic: exact le_sup <| mem_product.2 ⟨hb, hc⟩
state_before: case refine_2
F : Type ?u.55319
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.55331
κ : Type ?u.55334
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a : α
s : Finset β
t : Finset γ
f : β × γ → α
b : β
hb : b ∈ s
c : γ
hc : c ∈ t
⊢ f (b, c) ≤ sup (s ×ˢ t) f
Theorem: Order.Ideal.IsPrime.mem_or_mem
File: Mathlib/Order/PrimeIdeal.lean

tactic: contrapose!
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : IsPrime I
x y : P
⊢ x ⊓ y ∈ I → x ∈ I ∨ y ∈ I

tactic: let F := hI.compl_filter.toPFilter
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : IsPrime I
x y : P
⊢ ¬x ∈ I ∧ ¬y ∈ I → ¬x ⊓ y ∈ I

tactic: show x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : IsPrime I
x y : P
F : PFilter P := IsPFilter.toPFilter (_ : IsPFilter (↑Iᶜ))
⊢ ¬x ∈ I ∧ ¬y ∈ I → ¬x ⊓ y ∈ I

tactic: exact fun h => inf_mem h.1 h.2
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : IsPrime I
x y : P
F : PFilter P := IsPFilter.toPFilter (_ : IsPFilter (↑Iᶜ))
⊢ x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
Theorem: Setoid.sSup_def
File: Mathlib/Data/Setoid/Basic.lean

tactic: rw [sSup_eq_eqvGen, sSup_image]
state_before: α : Type u_1
β : Type ?u.8808
s : Set (Setoid α)
⊢ sSup s = EqvGen.Setoid (sSup (Rel '' s))

tactic: congr with (x y)
state_before: α : Type u_1
β : Type ?u.8808
s : Set (Setoid α)
⊢ (EqvGen.Setoid fun x y => ∃ r, r ∈ s ∧ Rel r x y) = EqvGen.Setoid (⨆ (a : Setoid α) (_ : a ∈ s), Rel a)

tactic: simp only [iSup_apply, iSup_Prop_eq, exists_prop]
state_before: case e_r.h.h.a
α : Type u_1
β : Type ?u.8808
s : Set (Setoid α)
x y : α
⊢ (∃ r, r ∈ s ∧ Rel r x y) ↔ iSup (fun a => ⨆ (_ : a ∈ s), Rel a) x y
Theorem: CategoryTheory.CoverDense.ext
File: Mathlib/CategoryTheory/Sites/DenseSubsite.lean

tactic: apply (ℱ.cond (Sieve.coverByImage G X) (H.is_cover X)).isSeparatedFor.ext
state_before: C : Type u_1
inst✝³ : Category C
D : Type u_3
inst✝² : Category D
E : Type ?u.5750
inst✝¹ : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.5802
inst✝ : Category A
G : C ⥤ D
H✝ H : CoverDense K G
ℱ : SheafOfTypes K
X : D
s t : ℱ.val.obj X.op
h : ∀ ⦃Y : C⦄ (f : G.obj Y ⟶ X), ℱ.val.map f.op s = ℱ.val.map f.op t
⊢ s = t

tactic: rintro Y _ ⟨Z, f₁, f₂, ⟨rfl⟩⟩
state_before: C : Type u_1
inst✝³ : Category C
D : Type u_3
inst✝² : Category D
E : Type ?u.5750
inst✝¹ : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.5802
inst✝ : Category A
G : C ⥤ D
H✝ H : CoverDense K G
ℱ : SheafOfTypes K
X : D
s t : ℱ.val.obj X.op
h : ∀ ⦃Y : C⦄ (f : G.obj Y ⟶ X), ℱ.val.map f.op s = ℱ.val.map f.op t
⊢ ∀ ⦃Y : D⦄ ⦃f : Y ⟶ X⦄, (Sieve.coverByImage G X).arrows f → ℱ.val.map f.op s = ℱ.val.map f.op t

tactic: simp [h f₂]
state_before: case intro.mk.refl
C : Type u_1
inst✝³ : Category C
D : Type u_3
inst✝² : Category D
E : Type ?u.5750
inst✝¹ : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.5802
inst✝ : Category A
G : C ⥤ D
H✝ H : CoverDense K G
ℱ : SheafOfTypes K
X : D
s t : ℱ.val.obj X.op
h : ∀ ⦃Y : C⦄ (f : G.obj Y ⟶ X), ℱ.val.map f.op s = ℱ.val.map f.op t
Y : D
Z : C
f₁ : Y ⟶ G.obj Z
f₂ : G.obj Z ⟶ X
⊢ ℱ.val.map (f₁ ≫ f₂).op s = ℱ.val.map (f₁ ≫ f₂).op t
Theorem: Cardinal.aleph_mul_aleph
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [Cardinal.mul_eq_max (aleph0_le_aleph o₁) (aleph0_le_aleph o₂), max_aleph_eq]
state_before: o₁ o₂ : Ordinal
⊢ aleph o₁ * aleph o₂ = aleph (max o₁ o₂)
Theorem: Subgroup.card_comap_dvd_of_injective
File: Mathlib/GroupTheory/Coset.lean

tactic: haveI : Fintype ((K.comap f).map f) :=
    Fintype.ofEquiv _ (equivMapOfInjective _ _ hf).toEquiv
state_before: α : Type u_2
inst✝³ : Group α
s t : Subgroup α
H : Type u_1
inst✝² : Group H
K : Subgroup H
inst✝¹ : Fintype { x // x ∈ K }
f : α →* H
inst✝ : Fintype { x // x ∈ comap f K }
hf : Injective ↑f
⊢ card { x // x ∈ comap f K } ∣ card { x // x ∈ K }

tactic: calc
  Fintype.card (K.comap f) = Fintype.card ((K.comap f).map f) :=
    Fintype.card_congr (equivMapOfInjective _ _ hf).toEquiv
  _ ∣ Fintype.card K := card_dvd_of_le (map_comap_le _ _)
state_before: α : Type u_2
inst✝³ : Group α
s t : Subgroup α
H : Type u_1
inst✝² : Group H
K : Subgroup H
inst✝¹ : Fintype { x // x ∈ K }
f : α →* H
inst✝ : Fintype { x // x ∈ comap f K }
hf : Injective ↑f
this : Fintype { x // x ∈ map f (comap f K) }
⊢ card { x // x ∈ comap f K } ∣ card { x // x ∈ K }
Theorem: Multiset.revzip_powersetAux_lemma
File: Mathlib/Data/Multiset/Powerset.lean

tactic: have :
  Forall₂ (fun (p : Multiset α × Multiset α) (s : Multiset α) => p = (s, ↑l - s)) (revzip l')
    ((revzip l').map Prod.fst) := by
  rw [forall₂_map_right_iff, forall₂_same]
  rintro ⟨s, t⟩ h
  dsimp
  rw [← H h, add_tsub_cancel_left]
state_before: α✝ : Type ?u.31102
α : Type u
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ revzip l' → x.fst + x.snd = ↑l
⊢ revzip l' = List.map (fun x => (x, ↑l - x)) l'

tactic: rw [← forall₂_eq_eq_eq, forall₂_map_right_iff]
state_before: α✝ : Type ?u.31102
α : Type u
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ revzip l' → x.fst + x.snd = ↑l
this : Forall₂ (fun p s => p = (s, ↑l - s)) (revzip l') (List.map Prod.fst (revzip l'))
⊢ revzip l' = List.map (fun x => (x, ↑l - x)) l'

tactic: simpa using this
state_before: α✝ : Type ?u.31102
α : Type u
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ revzip l' → x.fst + x.snd = ↑l
this : Forall₂ (fun p s => p = (s, ↑l - s)) (revzip l') (List.map Prod.fst (revzip l'))
⊢ Forall₂ (fun a c => a = (c, ↑l - c)) (revzip l') l'

tactic: rw [forall₂_map_right_iff, forall₂_same]
state_before: α✝ : Type ?u.31102
α : Type u
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ revzip l' → x.fst + x.snd = ↑l
⊢ Forall₂ (fun p s => p = (s, ↑l - s)) (revzip l') (List.map Prod.fst (revzip l'))

tactic: rintro ⟨s, t⟩ h
state_before: α✝ : Type ?u.31102
α : Type u
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ revzip l' → x.fst + x.snd = ↑l
⊢ ∀ (x : Multiset α × Multiset α), x ∈ revzip l' → x = (x.fst, ↑l - x.fst)

tactic: dsimp
state_before: case mk
α✝ : Type ?u.31102
α : Type u
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ revzip l' → x.fst + x.snd = ↑l
s t : Multiset α
h : (s, t) ∈ revzip l'
⊢ (s, t) = ((s, t).fst, ↑l - (s, t).fst)

tactic: rw [← H h, add_tsub_cancel_left]
state_before: case mk
α✝ : Type ?u.31102
α : Type u
inst✝ : DecidableEq α
l : List α
l' : List (Multiset α)
H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ revzip l' → x.fst + x.snd = ↑l
s t : Multiset α
h : (s, t) ∈ revzip l'
⊢ (s, t) = (s, ↑l - s)
Theorem: Submodule.apply_mem_map₂
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

tactic: rfl
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
m : M
n : N
p : Submodule R M
q : Submodule R N
hm : m ∈ p
hn : n ∈ q
⊢ ↑(↑f ↑{ val := m, property := hm }) n = ↑(↑f m) n
Theorem: Filter.blimsup_mono
File: Mathlib/Order/LiminfLimsup.lean

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.130759
ι : Type ?u.130762
inst✝ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
h : ∀ (x : β), p x → q x
a : α
ha : a ∈ {a | ∀ᶠ (x : β) in f, q x → u x ≤ a}
⊢ ∀ (x : β), (q x → u x ≤ a) → p x → u x ≤ a
Theorem: PowerSeries.le_order_add
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: refine' le_order _ _ _
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
⊢ min (order φ) (order ψ) ≤ order (φ + ψ)

tactic: simp (config := { contextual := true }) [coeff_of_lt_order]
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
⊢ ∀ (i : ℕ), ↑i < min (order φ) (order ψ) → ↑(coeff R i) (φ + ψ) = 0
Theorem: Complex.comap_exp_comap_abs_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: rw [Real.comap_exp_atTop]
state_before: ⊢ comap re (comap Real.exp atTop) = comap re atTop
Theorem: RingHom.is_integral_of_is_integral_mul_unit
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: obtain ⟨p, ⟨p_monic, hp⟩⟩ := hx
state_before: R : Type u_2
A : Type ?u.738556
B : Type ?u.738559
S : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x y : S
r : R
hr : ↑f r * y = 1
hx : IsIntegralElem f (x * y)
⊢ IsIntegralElem f x

tactic: refine' ⟨scaleRoots p r, ⟨(monic_scaleRoots_iff r).2 p_monic, _⟩⟩
state_before: case intro.intro
R : Type u_2
A : Type ?u.738556
B : Type ?u.738559
S : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x y : S
r : R
hr : ↑f r * y = 1
p : R[X]
p_monic : Monic p
hp : eval₂ f (x * y) p = 0
⊢ IsIntegralElem f x

tactic: convert scaleRoots_eval₂_eq_zero f hp
state_before: case intro.intro
R : Type u_2
A : Type ?u.738556
B : Type ?u.738559
S : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x y : S
r : R
hr : ↑f r * y = 1
p : R[X]
p_monic : Monic p
hp : eval₂ f (x * y) p = 0
⊢ eval₂ f x (scaleRoots p r) = 0

tactic: rw [mul_comm x y, ← mul_assoc, hr, one_mul]
state_before: case h.e'_2.h.e'_6
R : Type u_2
A : Type ?u.738556
B : Type ?u.738559
S : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x y : S
r : R
hr : ↑f r * y = 1
p : R[X]
p_monic : Monic p
hp : eval₂ f (x * y) p = 0
⊢ x = ↑f r * (x * y)
Theorem: Polynomial.leadingCoeff_mul_monic
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [H, leadingCoeff_eq_zero.1 H, zero_mul, leadingCoeff_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.692387
p q : R[X]
hq : Monic q
H : leadingCoeff p = 0
⊢ leadingCoeff (p * q) = leadingCoeff p

tactic: rw [leadingCoeff_mul', hq.leadingCoeff, mul_one]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.692387
p q : R[X]
hq : Monic q
H : leadingCoeff p ≠ 0
⊢ leadingCoeff (p * q) = leadingCoeff p

tactic: rwa [hq.leadingCoeff, mul_one]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.692387
p q : R[X]
hq : Monic q
H : leadingCoeff p ≠ 0
⊢ leadingCoeff p * leadingCoeff q ≠ 0
Theorem: Matrix.trace_mul_comm
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

tactic: rw [← trace_transpose, ← trace_transpose_mul, transpose_mul]
state_before: ι : Type ?u.25998
m : Type u_2
n : Type u_3
p : Type ?u.26007
α : Type ?u.26010
R : Type u_1
S : Type ?u.26016
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype p
inst✝¹ : AddCommMonoid R
inst✝ : CommSemigroup R
A : Matrix m n R
B : Matrix n m R
⊢ trace (A ⬝ B) = trace (B ⬝ A)
Theorem: Bitvec.toNat_append
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: cases' xs with xs P
state_before: m : ℕ
xs : Bitvec m
b : Bool
⊢ Bitvec.toNat (xs++ₜb ::ᵥ Vector.nil) = Bitvec.toNat xs * 2 + Bitvec.toNat (b ::ᵥ Vector.nil)

tactic: simp [bitsToNat_toList]
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
P : List.length xs = m
⊢ Bitvec.toNat ({ val := xs, property := P }++ₜb ::ᵥ Vector.nil) =
    Bitvec.toNat { val := xs, property := P } * 2 + Bitvec.toNat (b ::ᵥ Vector.nil)

tactic: clear P
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
P : List.length xs = m
⊢ bitsToNat (xs ++ [b]) = bitsToNat [b] + bitsToNat xs * 2

tactic: unfold bitsToNat
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
⊢ bitsToNat (xs ++ [b]) = bitsToNat [b] + bitsToNat xs * 2

tactic: rw [List.foldl, List.foldl]
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
⊢ List.foldl addLsb 0 (xs ++ [b]) = List.foldl addLsb 0 [b] + List.foldl addLsb 0 xs * 2

tactic: generalize h : 0 = x
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
⊢ List.foldl addLsb 0 (xs ++ [b]) = addLsb 0 b + List.foldl addLsb 0 xs * 2

tactic: conv in addLsb x b =>
  rw [← h]
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
x : ℕ
h : 0 = x
⊢ List.foldl addLsb x (xs ++ [b]) = addLsb x b + List.foldl addLsb x xs * 2

tactic: clear h
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
x : ℕ
h : 0 = x
⊢ List.foldl addLsb x (xs ++ [b]) = addLsb 0 b + List.foldl addLsb x xs * 2

tactic: simp
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
x : ℕ
⊢ List.foldl addLsb x (xs ++ [b]) = addLsb 0 b + List.foldl addLsb x xs * 2

tactic: induction' xs with x xs xs_ih generalizing x
state_before: case mk
m : ℕ
b : Bool
xs : List Bool
x : ℕ
⊢ addLsb (List.foldl addLsb x xs) b = addLsb 0 b + List.foldl addLsb x xs * 2

tactic: simp
state_before: case mk.nil
m : ℕ
b : Bool
x✝ x : ℕ
⊢ addLsb (List.foldl addLsb x []) b = addLsb 0 b + List.foldl addLsb x [] * 2

tactic: unfold addLsb
state_before: case mk.nil
m : ℕ
b : Bool
x✝ x : ℕ
⊢ addLsb x b = addLsb 0 b + x * 2

tactic: simp [Nat.mul_succ]
state_before: case mk.nil
m : ℕ
b : Bool
x✝ x : ℕ
⊢ (x + x + bif b then 1 else 0) = (0 + 0 + bif b then 1 else 0) + x * 2

tactic: simp
state_before: case mk.cons
m : ℕ
b : Bool
x✝¹ : ℕ
x✝ : Bool
xs : List Bool
xs_ih : ∀ (x : ℕ), addLsb (List.foldl addLsb x xs) b = addLsb 0 b + List.foldl addLsb x xs * 2
x : ℕ
⊢ addLsb (List.foldl addLsb x (x✝ :: xs)) b = addLsb 0 b + List.foldl addLsb x (x✝ :: xs) * 2

tactic: apply xs_ih
state_before: case mk.cons
m : ℕ
b : Bool
x✝¹ : ℕ
x✝ : Bool
xs : List Bool
xs_ih : ∀ (x : ℕ), addLsb (List.foldl addLsb x xs) b = addLsb 0 b + List.foldl addLsb x xs * 2
x : ℕ
⊢ addLsb (List.foldl addLsb (addLsb x x✝) xs) b = addLsb 0 b + List.foldl addLsb (addLsb x x✝) xs * 2
Theorem: LocalHomeomorph.extend_target_subset_range
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: simp only [mfld_simps]
state_before: 𝕜 : Type u_3
E : Type u_1
M : Type u_2
H : Type u_4
E' : Type ?u.140773
M' : Type ?u.140776
H' : Type ?u.140779
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ (extend f I).target ⊆ range ↑I
Theorem: Finset.map_traverse
File: Mathlib/Data/Finset/Functor.lean

tactic: unfold traverse
state_before: α β γ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : CommApplicative F
inst✝ : CommApplicative G
g : α → G β
h : β → γ
s : Finset α
⊢ Functor.map h <$> traverse g s = traverse (Functor.map h ∘ g) s

tactic: simp only [map_comp_coe, functor_norm]
state_before: α β γ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : CommApplicative F
inst✝ : CommApplicative G
g : α → G β
h : β → γ
s : Finset α
⊢ Functor.map h <$> Multiset.toFinset <$> Multiset.traverse g s.val =
    Multiset.toFinset <$> Multiset.traverse (Functor.map h ∘ g) s.val

tactic: rw [LawfulFunctor.comp_map, Multiset.map_traverse]
state_before: α β γ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : CommApplicative F
inst✝ : CommApplicative G
g : α → G β
h : β → γ
s : Finset α
⊢ (Multiset.toFinset ∘ Functor.map h) <$> Multiset.traverse g s.val =
    Multiset.toFinset <$> Multiset.traverse (Functor.map h ∘ g) s.val
Theorem: Char.ofNat_toNat
File: Mathlib/Data/Char.lean

tactic: rw [Char.ofNat, dif_pos h]
state_before: c : Char
h : isValidCharNat (toNat c)
⊢ ofNat (toNat c) = c

tactic: rfl
state_before: c : Char
h : isValidCharNat (toNat c)
⊢ ofNatAux (toNat c) h = c
Theorem: Matrix.vecMul_transpose
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.916992
m : Type u_2
n : Type u_1
o : Type ?u.917001
m' : o → Type ?u.917006
n' : o → Type ?u.917011
R : Type ?u.917014
S : Type ?u.917017
α : Type v
β : Type w
γ : Type ?u.917024
inst✝¹ : NonUnitalCommSemiring α
inst✝ : Fintype n
A : Matrix m n α
x : n → α
⊢ vecMul x Aᵀ = mulVec A x

tactic: apply dotProduct_comm
state_before: case h
l : Type ?u.916992
m : Type u_2
n : Type u_1
o : Type ?u.917001
m' : o → Type ?u.917006
n' : o → Type ?u.917011
R : Type ?u.917014
S : Type ?u.917017
α : Type v
β : Type w
γ : Type ?u.917024
inst✝¹ : NonUnitalCommSemiring α
inst✝ : Fintype n
A : Matrix m n α
x : n → α
x✝ : m
⊢ vecMul x Aᵀ x✝ = mulVec A x x✝
Theorem: ENNReal.Tendsto.const_mul
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [this, tendsto_const_nhds]
state_before: α : Type u_1
β : Type ?u.97009
γ : Type ?u.97012
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 b)
hb : b ≠ 0 ∨ a ≠ ⊤
this : a = 0
⊢ Tendsto (fun b => a * m b) f (𝓝 (a * b))
Theorem: MvPolynomial.totalDegree_C
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: have := Finsupp.support_single_subset hn
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.373398
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
a : R
n : σ →₀ ℕ
hn : n ∈ support (↑C a)
⊢ (sum n fun x e => e) ≤ 0

tactic: rw [Finset.mem_singleton] at this
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.373398
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
a : R
n : σ →₀ ℕ
hn : n ∈ support (↑C a)
this : n ∈ {0}
⊢ (sum n fun x e => e) ≤ 0

tactic: subst this
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.373398
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
a : R
n : σ →₀ ℕ
hn : n ∈ support (↑C a)
this : n = 0
⊢ (sum n fun x e => e) ≤ 0

tactic: exact le_rfl
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.373398
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
a : R
hn : 0 ∈ support (↑C a)
⊢ (sum 0 fun x e => e) ≤ 0
Theorem: iInf_nat_gt_zero_eq
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [← iInf_range, Nat.range_succ]
state_before: α : Type u_1
β : Type ?u.181361
β₂ : Type ?u.181364
γ : Type ?u.181367
ι : Sort ?u.181370
ι' : Sort ?u.181373
κ : ι → Sort ?u.181378
κ' : ι' → Sort ?u.181383
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
⊢ (⨅ (i : ℕ) (_ : i > 0), f i) = ⨅ (i : ℕ), f (i + 1)

tactic: simp
state_before: α : Type u_1
β : Type ?u.181361
β₂ : Type ?u.181364
γ : Type ?u.181367
ι : Sort ?u.181370
ι' : Sort ?u.181373
κ : ι → Sort ?u.181378
κ' : ι' → Sort ?u.181383
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
⊢ (⨅ (i : ℕ) (_ : i > 0), f i) = ⨅ (b : ℕ) (_ : b ∈ {i | 0 < i}), f b
Theorem: and_left_comm
File: Std/Logic.lean

tactic: rw [← and_assoc, ← and_assoc, @and_comm a b]
state_before: a b c : Prop
⊢ a ∧ b ∧ c ↔ b ∧ a ∧ c
Theorem: Matrix.mul_adjugate
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 n n α
⊢ A ⬝ adjugate A = det A • 1

tactic: rw [mul_apply, Pi.smul_apply, Pi.smul_apply, one_apply, smul_eq_mul, mul_boole]
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
i j : n
⊢ (A ⬝ adjugate A) i j = (det A • 1) i j

tactic: simp [mul_adjugate_apply, sum_cramer_apply, cramer_transpose_row_self, Pi.single_apply, eq_comm]
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
i j : n
⊢ ∑ j_1 : n, A i j_1 * adjugate A j_1 j = if i = j then det A else 0
Theorem: Rat.divInt_neg'
File: Std/Data/Rat/Lemmas.lean

tactic: rw [← neg_divInt_neg, Int.neg_neg]
state_before: num den : Int
⊢ num /. -den = -num /. den
Theorem: IsPGroup.nonempty_fixed_point_of_prime_not_dvd_card
File: Mathlib/GroupTheory/PGroup.lean

tactic: cases nonempty_fintype (fixedPoints G α)
state_before: p : ℕ
G : Type u_2
inst✝³ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝² : MulAction G α
inst✝¹ : Fintype α
hpα : ¬p ∣ card α
inst✝ : Finite ↑(fixedPoints G α)
⊢ Nonempty ↑(fixedPoints G α)

tactic: rw [← card_pos_iff, pos_iff_ne_zero]
state_before: case intro
p : ℕ
G : Type u_2
inst✝³ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝² : MulAction G α
inst✝¹ : Fintype α
hpα : ¬p ∣ card α
inst✝ : Finite ↑(fixedPoints G α)
val✝ : Fintype ↑(fixedPoints G α)
⊢ Nonempty ↑(fixedPoints G α)

tactic: contrapose! hpα
state_before: case intro
p : ℕ
G : Type u_2
inst✝³ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝² : MulAction G α
inst✝¹ : Fintype α
hpα : ¬p ∣ card α
inst✝ : Finite ↑(fixedPoints G α)
val✝ : Fintype ↑(fixedPoints G α)
⊢ card ↑(fixedPoints G α) ≠ 0

tactic: rw [← Nat.modEq_zero_iff_dvd, ← hpα]
state_before: case intro
p : ℕ
G : Type u_2
inst✝³ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝² : MulAction G α
inst✝¹ : Fintype α
inst✝ : Finite ↑(fixedPoints G α)
val✝ : Fintype ↑(fixedPoints G α)
hpα : card ↑(fixedPoints G α) = 0
⊢ p ∣ card α

tactic: exact hG.card_modEq_card_fixedPoints α
state_before: case intro
p : ℕ
G : Type u_2
inst✝³ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_1
inst✝² : MulAction G α
inst✝¹ : Fintype α
inst✝ : Finite ↑(fixedPoints G α)
val✝ : Fintype ↑(fixedPoints G α)
hpα : card ↑(fixedPoints G α) = 0
⊢ card α ≡ card ↑(fixedPoints G α) [MOD p]
Theorem: FreeSemigroup.length_mul
File: Mathlib/Algebra/Free.lean

tactic: simp [length, ← add_assoc, add_right_comm, List.length, List.length_append]
state_before: α : Type u
x y : FreeSemigroup α
⊢ length (x * y) = length x + length y