tasksource/leandojo huggingface dataset:
Theorem: LieSubmodule.range_incl
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp [← LieSubmodule.coe_toSubmodule_eq_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
⊢ LieModuleHom.range (incl N) = N
Theorem: CategoryTheory.ProjectiveResolution.liftOne_zero_comm
File: Mathlib/CategoryTheory/Preadditive/ProjectiveResolution.lean

tactic: dsimp [liftZero, liftOne]
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroObject C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasEqualizers C
inst✝ : HasImages C
Y Z : C
f : Y ⟶ Z
P : ProjectiveResolution Y
Q : ProjectiveResolution Z
⊢ liftOne f P Q ≫ HomologicalComplex.d Q.complex 1 0 = HomologicalComplex.d P.complex 1 0 ≫ liftZero f P Q

tactic: simp
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroObject C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasEqualizers C
inst✝ : HasImages C
Y Z : C
f : Y ⟶ Z
P : ProjectiveResolution Y
Q : ProjectiveResolution Z
⊢ Exact.lift
        (HomologicalComplex.d P.complex 1 0 ≫
          factorThru (HomologicalComplex.Hom.f P.π 0 ≫ f) (HomologicalComplex.Hom.f Q.π 0))
        (HomologicalComplex.d Q.complex 1 0) (HomologicalComplex.Hom.f Q.π 0)
        (_ : Exact (HomologicalComplex.d Q.complex 1 0) (HomologicalComplex.Hom.f Q.π 0))
        (_ :
          (HomologicalComplex.d P.complex 1 0 ≫
                factorThru (HomologicalComplex.Hom.f P.π 0 ≫ f) (HomologicalComplex.Hom.f Q.π 0)) ≫
              HomologicalComplex.Hom.f Q.π 0 =
            0) ≫
      HomologicalComplex.d Q.complex 1 0 =
    HomologicalComplex.d P.complex 1 0 ≫
      factorThru (HomologicalComplex.Hom.f P.π 0 ≫ f) (HomologicalComplex.Hom.f Q.π 0)
Theorem: Matrix.toBlock_mul_eq_add
File: Mathlib/Data/Matrix/Block.lean

tactic: classical
  ext (i k)
  simp only [toBlock_apply, mul_apply, Pi.add_apply]
  exact (Fintype.sum_subtype_add_sum_subtype q fun x => A (↑i) x * B x ↑k).symm
state_before: l : Type ?u.270844
m✝ : Type ?u.270847
n✝ : Type ?u.270850
o : Type ?u.270853
p✝ : Type ?u.270856
q✝ : Type ?u.270859
m' : o → Type ?u.270864
n' : o → Type ?u.270869
p' : o → Type ?u.270874
R : Type u_4
S : Type ?u.270880
α : Type ?u.270883
β : Type ?u.270886
inst✝² : CommRing R
m : Type u_1
n : Type u_2
k : Type u_3
inst✝¹ : Fintype n
p : m → Prop
q : n → Prop
inst✝ : DecidablePred q
r : k → Prop
A : Matrix m n R
B : Matrix n k R
⊢ toBlock (A ⬝ B) p r = toBlock A p q ⬝ toBlock B q r + (toBlock A p fun i => ¬q i) ⬝ toBlock B (fun i => ¬q i) r

tactic: ext (i k)
state_before: l : Type ?u.270844
m✝ : Type ?u.270847
n✝ : Type ?u.270850
o : Type ?u.270853
p✝ : Type ?u.270856
q✝ : Type ?u.270859
m' : o → Type ?u.270864
n' : o → Type ?u.270869
p' : o → Type ?u.270874
R : Type u_4
S : Type ?u.270880
α : Type ?u.270883
β : Type ?u.270886
inst✝² : CommRing R
m : Type u_1
n : Type u_2
k : Type u_3
inst✝¹ : Fintype n
p : m → Prop
q : n → Prop
inst✝ : DecidablePred q
r : k → Prop
A : Matrix m n R
B : Matrix n k R
⊢ toBlock (A ⬝ B) p r = toBlock A p q ⬝ toBlock B q r + (toBlock A p fun i => ¬q i) ⬝ toBlock B (fun i => ¬q i) r

tactic: simp only [toBlock_apply, mul_apply, Pi.add_apply]
state_before: case a.h
l : Type ?u.270844
m✝ : Type ?u.270847
n✝ : Type ?u.270850
o : Type ?u.270853
p✝ : Type ?u.270856
q✝ : Type ?u.270859
m' : o → Type ?u.270864
n' : o → Type ?u.270869
p' : o → Type ?u.270874
R : Type u_4
S : Type ?u.270880
α : Type ?u.270883
β : Type ?u.270886
inst✝² : CommRing R
m : Type u_1
n : Type u_2
k✝ : Type u_3
inst✝¹ : Fintype n
p : m → Prop
q : n → Prop
inst✝ : DecidablePred q
r : k✝ → Prop
A : Matrix m n R
B : Matrix n k✝ R
i : { a // p a }
k : { a // r a }
⊢ toBlock (A ⬝ B) p r i k =
    (toBlock A p q ⬝ toBlock B q r + (toBlock A p fun i => ¬q i) ⬝ toBlock B (fun i => ¬q i) r) i k

tactic: exact (Fintype.sum_subtype_add_sum_subtype q fun x => A (↑i) x * B x ↑k).symm
state_before: case a.h
l : Type ?u.270844
m✝ : Type ?u.270847
n✝ : Type ?u.270850
o : Type ?u.270853
p✝ : Type ?u.270856
q✝ : Type ?u.270859
m' : o → Type ?u.270864
n' : o → Type ?u.270869
p' : o → Type ?u.270874
R : Type u_4
S : Type ?u.270880
α : Type ?u.270883
β : Type ?u.270886
inst✝² : CommRing R
m : Type u_1
n : Type u_2
k✝ : Type u_3
inst✝¹ : Fintype n
p : m → Prop
q : n → Prop
inst✝ : DecidablePred q
r : k✝ → Prop
A : Matrix m n R
B : Matrix n k✝ R
i : { a // p a }
k : { a // r a }
⊢ ∑ j : n, A (↑i) j * B j ↑k =
    (toBlock A p q ⬝ toBlock B q r + (toBlock A p fun i => ¬q i) ⬝ toBlock B (fun i => ¬q i) r) i k
Theorem: Set.seq_of_forall_finite_exists
File: Mathlib/Data/Set/Finite.lean

tactic: haveI : Nonempty γ := (h ∅ finite_empty).nonempty
state_before: α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
h : ∀ (t : Set γ), Set.Finite t → ∃ c, P c t
⊢ ∃ u, ∀ (n : ℕ), P (u n) (u '' Iio n)

tactic: choose! c hc using h
state_before: α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
h : ∀ (t : Set γ), Set.Finite t → ∃ c, P c t
this : Nonempty γ
⊢ ∃ u, ∀ (n : ℕ), P (u n) (u '' Iio n)

tactic: set f : (n : ℕ) → (g : (m : ℕ) → m < n → γ) → γ := fun n g => c (range fun k : Iio n => g k.1 k.2)
state_before: α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
this : Nonempty γ
c : Set γ → γ
hc : ∀ (t : Set γ), Set.Finite t → P (c t) t
⊢ ∃ u, ∀ (n : ℕ), P (u n) (u '' Iio n)

tactic: set u : ℕ → γ := fun n => Nat.strongRecOn' n f
state_before: α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
this : Nonempty γ
c : Set γ → γ
hc : ∀ (t : Set γ), Set.Finite t → P (c t) t
f : (n : ℕ) → ((m : ℕ) → m < n → γ) → γ := fun n g => c (range fun k => g ↑k (_ : ↑k ∈ Iio n))
⊢ ∃ u, ∀ (n : ℕ), P (u n) (u '' Iio n)

tactic: refine' ⟨u, fun n => _⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
this : Nonempty γ
c : Set γ → γ
hc : ∀ (t : Set γ), Set.Finite t → P (c t) t
f : (n : ℕ) → ((m : ℕ) → m < n → γ) → γ := fun n g => c (range fun k => g ↑k (_ : ↑k ∈ Iio n))
u : ℕ → γ := fun n => Nat.strongRecOn' n f
⊢ ∃ u, ∀ (n : ℕ), P (u n) (u '' Iio n)

tactic: convert hc (u '' Iio n) ((finite_lt_nat _).image _)
state_before: α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
this : Nonempty γ
c : Set γ → γ
hc : ∀ (t : Set γ), Set.Finite t → P (c t) t
f : (n : ℕ) → ((m : ℕ) → m < n → γ) → γ := fun n g => c (range fun k => g ↑k (_ : ↑k ∈ Iio n))
u : ℕ → γ := fun n => Nat.strongRecOn' n f
n : ℕ
⊢ P (u n) (u '' Iio n)

tactic: rw [image_eq_range]
state_before: case h.e'_1
α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
this : Nonempty γ
c : Set γ → γ
hc : ∀ (t : Set γ), Set.Finite t → P (c t) t
f : (n : ℕ) → ((m : ℕ) → m < n → γ) → γ := fun n g => c (range fun k => g ↑k (_ : ↑k ∈ Iio n))
u : ℕ → γ := fun n => Nat.strongRecOn' n f
n : ℕ
⊢ u n = c (u '' Iio n)

tactic: exact Nat.strongRecOn'_beta
state_before: case h.e'_1
α : Type u
β : Type v
ι : Sort w
γ✝ : Type x
γ : Type u_1
P : γ → Set γ → Prop
this : Nonempty γ
c : Set γ → γ
hc : ∀ (t : Set γ), Set.Finite t → P (c t) t
f : (n : ℕ) → ((m : ℕ) → m < n → γ) → γ := fun n g => c (range fun k => g ↑k (_ : ↑k ∈ Iio n))
u : ℕ → γ := fun n => Nat.strongRecOn' n f
n : ℕ
⊢ u n = c (range fun x => u ↑x)
Theorem: Finset.inter_left_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_inter, and_left_comm]
state_before: α : Type u_1
β : Type ?u.181971
γ : Type ?u.181974
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ s₃ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ (s₂ ∩ s₃) ↔ x✝ ∈ s₂ ∩ (s₁ ∩ s₃)
Theorem: CategoryTheory.exact_comp_hom_inv_comp_iff
File: Mathlib/Algebra/Homology/Exact.lean

tactic: simpa using exact_comp_inv_hom_comp i h
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
i : B ≅ D
h : Exact (f ≫ i.hom) (i.inv ≫ g)
⊢ Exact f g
Theorem: LinearMap.IsSymmetric.isSelfAdjoint
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rwa [← ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric] at hA
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1397379
G : Type ?u.1397382
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
A : E →L[𝕜] E
hA : LinearMap.IsSymmetric ↑A
⊢ IsSelfAdjoint A
Theorem: CategoryTheory.cancel_mono_id
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: convert cancel_mono f
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
g : X ⟶ X
⊢ g ≫ f = f ↔ g = 𝟙 X

tactic: simp
state_before: case h.e'_1.h.e'_3.h
C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
g : X ⟶ X
⊢ f = 𝟙 X ≫ f
Theorem: Nat.not_even_bit1
File: Mathlib/Data/Nat/Parity.lean

tactic: simp [bit1, parity_simps]
state_before: m n✝ n : ℕ
⊢ ¬Even (bit1 n)
Theorem: Multiset.le_add_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa using add_le_add_left (zero_le t) s
state_before: α : Type u_1
β : Type ?u.41033
γ : Type ?u.41036
s t : Multiset α
⊢ s ≤ s + t
Theorem: Multiset.toFinset_sum_count_eq
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp
state_before: ι : Type ?u.919655
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
s : Multiset α
⊢ sum (map (fun x => 1) s) = ↑card s
Theorem: AlgebraicGeometry.PresheafedSpace.stalkMap_germ
File: Mathlib/AlgebraicGeometry/Stalks.lean

tactic: rw [stalkMap, stalkFunctor_map_germ_assoc, stalkPushforward_germ]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α : X ⟶ Y
U : Opens ↑↑Y
x : { x // x ∈ (Opens.map α.base).obj U }
⊢ germ Y.presheaf
        { val := (CategoryTheory.forget TopCat).map α.base ↑x, property := (_ : ↑x ∈ (Opens.map α.base).obj U) } ≫
      stalkMap α ↑x =
    α.c.app U.op ≫ germ X.presheaf x
Theorem: Ordinal.nadd_le_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_def]
state_before: a b c : Ordinal
⊢ b ♯ c ≤ a ↔ (∀ (b' : Ordinal), b' < b → b' ♯ c < a) ∧ ∀ (c' : Ordinal), c' < c → b ♯ c' < a

tactic: simp [blsub_le_iff]
state_before: a b c : Ordinal
⊢ max (blsub b fun a' x => a' ♯ c) (blsub c fun b' x => b ♯ b') ≤ a ↔
    (∀ (b' : Ordinal), b' < b → b' ♯ c < a) ∧ ∀ (c' : Ordinal), c' < c → b ♯ c' < a
Theorem: norm_injOn_ray_left
File: Mathlib/Analysis/NormedSpace/Ray.lean

tactic: rintro y hy z hz h
state_before: E : Type ?u.17528
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hx : x ≠ 0
⊢ Set.InjOn Norm.norm {y | SameRay ℝ x y}

tactic: rcases hy.exists_nonneg_left hx with ⟨r, hr, rfl⟩
state_before: E : Type ?u.17528
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y✝ : F
hx : x ≠ 0
y : F
hy : y ∈ {y | SameRay ℝ x y}
z : F
hz : z ∈ {y | SameRay ℝ x y}
h : ‖y‖ = ‖z‖
⊢ y = z

tactic: rcases hz.exists_nonneg_left hx with ⟨s, hs, rfl⟩
state_before: case intro.intro
E : Type ?u.17528
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hx : x ≠ 0
z : F
hz : z ∈ {y | SameRay ℝ x y}
r : ℝ
hr : 0 ≤ r
hy : r • x ∈ {y | SameRay ℝ x y}
h : ‖r • x‖ = ‖z‖
⊢ r • x = z

tactic: rw [norm_smul, norm_smul, mul_left_inj' (norm_ne_zero_iff.2 hx), norm_of_nonneg hr,
  norm_of_nonneg hs] at h
state_before: case intro.intro.intro.intro
E : Type ?u.17528
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hx : x ≠ 0
r : ℝ
hr : 0 ≤ r
hy : r • x ∈ {y | SameRay ℝ x y}
s : ℝ
hs : 0 ≤ s
hz : s • x ∈ {y | SameRay ℝ x y}
h : ‖r • x‖ = ‖s • x‖
⊢ r • x = s • x

tactic: rw [h]
state_before: case intro.intro.intro.intro
E : Type ?u.17528
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hx : x ≠ 0
r : ℝ
hr : 0 ≤ r
hy : r • x ∈ {y | SameRay ℝ x y}
s : ℝ
hs : 0 ≤ s
hz : s • x ∈ {y | SameRay ℝ x y}
h : r = s
⊢ r • x = s • x
Theorem: Filter.map_map₂_antidistrib
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_swap m]
state_before: α : Type u_3
α' : Type u_6
β : Type u_4
β' : Type u_5
γ : Type u_2
γ' : Type ?u.43638
δ : Type u_1
δ' : Type ?u.43644
ε : Type ?u.43647
ε' : Type ?u.43650
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
n : γ → δ
m' : β' → α' → δ
n₁ : β → β'
n₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), n (m a b) = m' (n₁ b) (n₂ a)
⊢ map n (map₂ m f g) = map₂ m' (map n₁ g) (map n₂ f)

tactic: exact map_map₂_distrib fun _ _ => h_antidistrib _ _
state_before: α : Type u_3
α' : Type u_6
β : Type u_4
β' : Type u_5
γ : Type u_2
γ' : Type ?u.43638
δ : Type u_1
δ' : Type ?u.43644
ε : Type ?u.43647
ε' : Type ?u.43650
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
n : γ → δ
m' : β' → α' → δ
n₁ : β → β'
n₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), n (m a b) = m' (n₁ b) (n₂ a)
⊢ map n (map₂ (fun a b => m b a) g f) = map₂ m' (map n₁ g) (map n₂ f)
Theorem: intervalIntegral.integral_comp_mul_left
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [mul_comm c] using integral_comp_mul_right f hc
state_before: ι : Type ?u.14834153
𝕜 : Type ?u.14834156
E : Type u_1
F : Type ?u.14834162
A : Type ?u.14834165
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f : ℝ → E
hc : c ≠ 0
⊢ (∫ (x : ℝ) in a..b, f (c * x)) = c⁻¹ • ∫ (x : ℝ) in c * a..c * b, f x
Theorem: ENNReal.summable_toNNReal_of_tsum_ne_top
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simpa only [← tsum_coe_ne_top_iff_summable, toNNReal_apply_of_tsum_ne_top hf] using hf
state_before: α✝ : Type ?u.260873
β : Type ?u.260876
γ : Type ?u.260879
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_1
f : α → ℝ≥0∞
hf : (∑' (i : α), f i) ≠ ⊤
⊢ Summable (ENNReal.toNNReal ∘ f)
Theorem: EMetric.mem_closedBall_self
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: rw [mem_closedBall, edist_self]
state_before: α : Type u
β : Type v
X : Type ?u.188879
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ x ∈ closedBall x ε

tactic: apply zero_le
state_before: α : Type u
β : Type v
X : Type ?u.188879
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ 0 ≤ ε
Theorem: Turing.TM1to1.supportsStmt_move
File: Mathlib/Computability/TuringMachine.lean

tactic: suffices ∀ {i}, SupportsStmt S ((Stmt.move d^[i]) q) = _ from this
state_before: Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
d : Dir
q : Stmt Bool Λ' σ
⊢ SupportsStmt S (move d q) = SupportsStmt S q

tactic: intro i
state_before: Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
d : Dir
q : Stmt Bool Λ' σ
⊢ ∀ {i : ℕ}, SupportsStmt S ((Stmt.move d^[i]) q) = SupportsStmt S q

tactic: induction i generalizing q <;> simp only [*, iterate]
state_before: Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
d : Dir
q : Stmt Bool Λ' σ
i : ℕ
⊢ SupportsStmt S ((Stmt.move d^[i]) q) = SupportsStmt S q

tactic: rfl
state_before: case succ
Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
d : Dir
n✝ : ℕ
n_ih✝ : ∀ {q : Stmt Bool Λ' σ}, SupportsStmt S ((Stmt.move d^[n✝]) q) = SupportsStmt S q
q : Stmt Bool Λ' σ
⊢ SupportsStmt S (Stmt.move d q) = SupportsStmt S q
Theorem: Function.Commute.minimalPeriod_of_comp_dvd_lcm
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← isPeriodicPt_iff_minimalPeriod_dvd]
state_before: α : Type u_1
β : Type ?u.27360
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Commute f g
⊢ minimalPeriod (f ∘ g) x ∣ lcm (minimalPeriod f x) (minimalPeriod g x)

tactic: exact (isPeriodicPt_minimalPeriod f x).comp_lcm h (isPeriodicPt_minimalPeriod g x)
state_before: α : Type u_1
β : Type ?u.27360
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Commute f g
⊢ IsPeriodicPt (f ∘ g) (lcm (minimalPeriod f x) (minimalPeriod g x)) x
Theorem: List.mem_getLast?_cons
File: Mathlib/Data/List/Basic.lean

tactic: contradiction
state_before: ι : Type ?u.36630
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x y : α
x✝ : x ∈ getLast? []
⊢ x ∈ getLast? [y]
Theorem: Polynomial.toFinsupp_monomial
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp [monomial]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
⊢ (↑(monomial n) r).toFinsupp = Finsupp.single n r
Theorem: Zsqrtd.nonnegg_comm
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: induction x <;> induction y <;> rfl
state_before: d✝ : ℤ
c d : ℕ
x y : ℤ
⊢ Nonnegg c d x y = Nonnegg d c y x
Theorem: DirectSum.Gmodule.smulAddMonoidHom_apply_of_of
File: Mathlib/Algebra/Module/GradedModule.lean

tactic: simp [smulAddMonoidHom]
state_before: ι : Type u_1
A : ι → Type u_2
M : ι → Type u_3
inst✝⁵ : AddMonoid ι
inst✝⁴ : (i : ι) → AddCommMonoid (A i)
inst✝³ : (i : ι) → AddCommMonoid (M i)
inst✝² : DecidableEq ι
inst✝¹ : GMonoid A
inst✝ : Gmodule A M
i j : ι
x : A i
y : M j
⊢ ↑(↑(smulAddMonoidHom A M) (↑(of A i) x)) (↑(of M j) y) = ↑(of M (i + j)) (GSmul.smul x y)
Theorem: Relation.cutExpand_le_invImage_lex
File: Mathlib/Logic/Hydra.lean

tactic: rintro s t ⟨u, a, hr, he⟩
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
⊢ CutExpand r ≤ InvImage (Finsupp.Lex (rᶜ ⊓ fun x x_1 => x ≠ x_1) fun x x_1 => x < x_1) ↑toFinsupp

tactic: replace hr := fun a' ↦ mt (hr a')
state_before: case intro.intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s t u : Multiset α
a : α
hr : ∀ (a' : α), a' ∈ u → r a' a
he : s + {a} = t + u
⊢ InvImage (Finsupp.Lex (rᶜ ⊓ fun x x_1 => x ≠ x_1) fun x x_1 => x < x_1) (↑toFinsupp) s t

tactic: refine ⟨a, fun b h ↦ ?_, ?_⟩ <;> simp_rw [toFinsupp_apply]
state_before: case intro.intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s t u : Multiset α
a : α
he : s + {a} = t + u
hr : ∀ (a' : α), ¬r a' a → ¬a' ∈ u
⊢ InvImage (Finsupp.Lex (rᶜ ⊓ fun x x_1 => x ≠ x_1) fun x x_1 => x < x_1) (↑toFinsupp) s t

tactic: apply_fun count b  at he
state_before: case intro.intro.intro.refine_1
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s t u : Multiset α
a : α
he : s + {a} = t + u
hr : ∀ (a' : α), ¬r a' a → ¬a' ∈ u
b : α
h : (rᶜ ⊓ fun x x_1 => x ≠ x_1) b a
⊢ count b s = count b t

tactic: simpa only [count_add, count_singleton, if_neg h.2, add_zero, count_eq_zero.2 (hr b h.1)]
  using he
state_before: case intro.intro.intro.refine_1
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s t u : Multiset α
a : α
hr : ∀ (a' : α), ¬r a' a → ¬a' ∈ u
b : α
h : (rᶜ ⊓ fun x x_1 => x ≠ x_1) b a
he : count b (s + {a}) = count b (t + u)
⊢ count b s = count b t

tactic: apply_fun count a  at he
state_before: case intro.intro.intro.refine_2
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s t u : Multiset α
a : α
he : s + {a} = t + u
hr : ∀ (a' : α), ¬r a' a → ¬a' ∈ u
⊢ count a s < count a t

tactic: simp only [count_add, count_singleton_self, count_eq_zero.2 (hr _ (irrefl_of r a)),
  add_zero] at he
state_before: case intro.intro.intro.refine_2
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s t u : Multiset α
a : α
hr : ∀ (a' : α), ¬r a' a → ¬a' ∈ u
he : count a (s + {a}) = count a (t + u)
⊢ count a s < count a t

tactic: exact he ▸ Nat.lt_succ_self _
state_before: case intro.intro.intro.refine_2
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s t u : Multiset α
a : α
hr : ∀ (a' : α), ¬r a' a → ¬a' ∈ u
he : count a s + 1 = count a t
⊢ count a s < count a t
Theorem: Finset.subtype_map_of_mem
File: Mathlib/Data/Finset/Image.lean

tactic: simpa [subtype_map] using h
state_before: α : Type u_1
β : Type ?u.133134
γ : Type ?u.133137
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
h : ∀ (x : α), x ∈ s → p x
⊢ ∀ (a : α), a ∈ map (Embedding.subtype p) (Finset.subtype p s) ↔ a ∈ s
Theorem: Nat.dvd_iff_dvd_ofDigits
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [← Int.coe_nat_dvd]
state_before: n✝ b b' : ℕ
c : ℤ
h : ↑b ∣ ↑b' - c
n : ℕ
⊢ b ∣ n ↔ ↑b ∣ ofDigits c (digits b' n)

tactic: exact
  dvd_iff_dvd_of_dvd_sub (zmodeq_ofDigits_digits b b' c (Int.modEq_iff_dvd.2 h).symm _).symm.dvd
state_before: n✝ b b' : ℕ
c : ℤ
h : ↑b ∣ ↑b' - c
n : ℕ
⊢ ↑b ∣ ↑n ↔ ↑b ∣ ofDigits c (digits b' n)
Theorem: TopCat.Presheaf.Pushforward.comp_inv_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: simp [comp]
state_before: C : Type u
inst✝ : Category C
X : TopCat
ℱ : Presheaf C X
Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
U : (Opens ↑Z)ᵒᵖ
⊢ (comp ℱ f g).inv.app U = 𝟙 ((g _* (f _* ℱ)).obj U)
Theorem: Units.inv_eq_of_mul_eq_one_left
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [one_mul]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : a * ↑u = 1
⊢ ↑u⁻¹ = 1 * ↑u⁻¹

tactic: rw [← h, mul_inv_cancel_right]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : a * ↑u = 1
⊢ 1 * ↑u⁻¹ = a
Theorem: Polynomial.degree_C_lt_degree_C_mul_X
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [degree_C_mul_X ha] using degree_C_lt
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.806235
ha : a ≠ 0
⊢ degree (↑C b) < degree (↑C a * X)
Theorem: SimpleGraph.adjMatrix_mulVec_const_apply
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [degree]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.64270
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype V
inst✝ : Semiring α
a : α
v : V
⊢ mulVec (adjMatrix α G) (Function.const V a) v = ↑(degree G v) * a
Theorem: Subgroup.index_inf_ne_zero
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← relindex_top_right] at hH hK⊢
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hH : index H ≠ 0
hK : index K ≠ 0
⊢ index (H ⊓ K) ≠ 0

tactic: exact relindex_inf_ne_zero hH hK
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hH : relindex H ⊤ ≠ 0
hK : relindex K ⊤ ≠ 0
⊢ relindex (H ⊓ K) ⊤ ≠ 0
Theorem: Function.fixedPoints_id
File: Mathlib/Dynamics/FixedPoints/Basic.lean

tactic: simpa using isFixedPt_id _
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n k : ℕ
e : Perm α
x✝ : α
⊢ x✝ ∈ fixedPoints id ↔ x✝ ∈ Set.univ
Theorem: Set.image_const_add_Ici
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: simp only [add_comm a, image_add_const_Ici]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ici b = Ici (a + b)
Theorem: iSup_inf_iSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp_rw [iSup_inf_eq, inf_iSup_eq, iSup_prod]
state_before: α : Type u
β : Type v
ι✝ : Sort w
κ : ι✝ → Sort ?u.4392
inst✝ : Frame α
s t : Set α
a b : α
ι : Type u_1
ι' : Type u_2
f : ι → α
g : ι' → α
⊢ ((⨆ (i : ι), f i) ⊓ ⨆ (j : ι'), g j) = ⨆ (i : ι × ι'), f i.fst ⊓ g i.snd
Theorem: Real.pi_lt_315
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: pi_upper_bound [140 / 99, 279 / 151, 51 / 26, 412 / 207]
state_before: ⊢ π < 3.15